1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package dataexchange 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/dataexchange/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/encoding/httpbinding" 12 smithyjson "github.com/aws/smithy-go/encoding/json" 13 "github.com/aws/smithy-go/middleware" 14 smithyhttp "github.com/aws/smithy-go/transport/http" 15) 16 17type awsRestjson1_serializeOpCancelJob struct { 18} 19 20func (*awsRestjson1_serializeOpCancelJob) ID() string { 21 return "OperationSerializer" 22} 23 24func (m *awsRestjson1_serializeOpCancelJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 25 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 26) { 27 request, ok := in.Request.(*smithyhttp.Request) 28 if !ok { 29 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 30 } 31 32 input, ok := in.Parameters.(*CancelJobInput) 33 _ = input 34 if !ok { 35 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 36 } 37 38 opPath, opQuery := httpbinding.SplitURI("/v1/jobs/{JobId}") 39 request.URL.Path = opPath 40 if len(request.URL.RawQuery) > 0 { 41 request.URL.RawQuery = "&" + opQuery 42 } else { 43 request.URL.RawQuery = opQuery 44 } 45 46 request.Method = "DELETE" 47 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 48 if err != nil { 49 return out, metadata, &smithy.SerializationError{Err: err} 50 } 51 52 if err := awsRestjson1_serializeOpHttpBindingsCancelJobInput(input, restEncoder); err != nil { 53 return out, metadata, &smithy.SerializationError{Err: err} 54 } 55 56 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 57 return out, metadata, &smithy.SerializationError{Err: err} 58 } 59 in.Request = request 60 61 return next.HandleSerialize(ctx, in) 62} 63func awsRestjson1_serializeOpHttpBindingsCancelJobInput(v *CancelJobInput, encoder *httpbinding.Encoder) error { 64 if v == nil { 65 return fmt.Errorf("unsupported serialization of nil %T", v) 66 } 67 68 if v.JobId == nil || len(*v.JobId) == 0 { 69 return &smithy.SerializationError{Err: fmt.Errorf("input member JobId must not be empty")} 70 } 71 if v.JobId != nil { 72 if err := encoder.SetURI("JobId").String(*v.JobId); err != nil { 73 return err 74 } 75 } 76 77 return nil 78} 79 80type awsRestjson1_serializeOpCreateDataSet struct { 81} 82 83func (*awsRestjson1_serializeOpCreateDataSet) ID() string { 84 return "OperationSerializer" 85} 86 87func (m *awsRestjson1_serializeOpCreateDataSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 88 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 89) { 90 request, ok := in.Request.(*smithyhttp.Request) 91 if !ok { 92 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 93 } 94 95 input, ok := in.Parameters.(*CreateDataSetInput) 96 _ = input 97 if !ok { 98 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 99 } 100 101 opPath, opQuery := httpbinding.SplitURI("/v1/data-sets") 102 request.URL.Path = opPath 103 if len(request.URL.RawQuery) > 0 { 104 request.URL.RawQuery = "&" + opQuery 105 } else { 106 request.URL.RawQuery = opQuery 107 } 108 109 request.Method = "POST" 110 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 111 if err != nil { 112 return out, metadata, &smithy.SerializationError{Err: err} 113 } 114 115 restEncoder.SetHeader("Content-Type").String("application/json") 116 117 jsonEncoder := smithyjson.NewEncoder() 118 if err := awsRestjson1_serializeOpDocumentCreateDataSetInput(input, jsonEncoder.Value); err != nil { 119 return out, metadata, &smithy.SerializationError{Err: err} 120 } 121 122 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 123 return out, metadata, &smithy.SerializationError{Err: err} 124 } 125 126 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 127 return out, metadata, &smithy.SerializationError{Err: err} 128 } 129 in.Request = request 130 131 return next.HandleSerialize(ctx, in) 132} 133func awsRestjson1_serializeOpHttpBindingsCreateDataSetInput(v *CreateDataSetInput, encoder *httpbinding.Encoder) error { 134 if v == nil { 135 return fmt.Errorf("unsupported serialization of nil %T", v) 136 } 137 138 return nil 139} 140 141func awsRestjson1_serializeOpDocumentCreateDataSetInput(v *CreateDataSetInput, value smithyjson.Value) error { 142 object := value.Object() 143 defer object.Close() 144 145 if len(v.AssetType) > 0 { 146 ok := object.Key("AssetType") 147 ok.String(string(v.AssetType)) 148 } 149 150 if v.Description != nil { 151 ok := object.Key("Description") 152 ok.String(*v.Description) 153 } 154 155 if v.Name != nil { 156 ok := object.Key("Name") 157 ok.String(*v.Name) 158 } 159 160 if v.Tags != nil { 161 ok := object.Key("Tags") 162 if err := awsRestjson1_serializeDocumentMapOf__string(v.Tags, ok); err != nil { 163 return err 164 } 165 } 166 167 return nil 168} 169 170type awsRestjson1_serializeOpCreateJob struct { 171} 172 173func (*awsRestjson1_serializeOpCreateJob) ID() string { 174 return "OperationSerializer" 175} 176 177func (m *awsRestjson1_serializeOpCreateJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 178 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 179) { 180 request, ok := in.Request.(*smithyhttp.Request) 181 if !ok { 182 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 183 } 184 185 input, ok := in.Parameters.(*CreateJobInput) 186 _ = input 187 if !ok { 188 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 189 } 190 191 opPath, opQuery := httpbinding.SplitURI("/v1/jobs") 192 request.URL.Path = opPath 193 if len(request.URL.RawQuery) > 0 { 194 request.URL.RawQuery = "&" + opQuery 195 } else { 196 request.URL.RawQuery = opQuery 197 } 198 199 request.Method = "POST" 200 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 201 if err != nil { 202 return out, metadata, &smithy.SerializationError{Err: err} 203 } 204 205 restEncoder.SetHeader("Content-Type").String("application/json") 206 207 jsonEncoder := smithyjson.NewEncoder() 208 if err := awsRestjson1_serializeOpDocumentCreateJobInput(input, jsonEncoder.Value); err != nil { 209 return out, metadata, &smithy.SerializationError{Err: err} 210 } 211 212 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 213 return out, metadata, &smithy.SerializationError{Err: err} 214 } 215 216 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 217 return out, metadata, &smithy.SerializationError{Err: err} 218 } 219 in.Request = request 220 221 return next.HandleSerialize(ctx, in) 222} 223func awsRestjson1_serializeOpHttpBindingsCreateJobInput(v *CreateJobInput, encoder *httpbinding.Encoder) error { 224 if v == nil { 225 return fmt.Errorf("unsupported serialization of nil %T", v) 226 } 227 228 return nil 229} 230 231func awsRestjson1_serializeOpDocumentCreateJobInput(v *CreateJobInput, value smithyjson.Value) error { 232 object := value.Object() 233 defer object.Close() 234 235 if v.Details != nil { 236 ok := object.Key("Details") 237 if err := awsRestjson1_serializeDocumentRequestDetails(v.Details, ok); err != nil { 238 return err 239 } 240 } 241 242 if len(v.Type) > 0 { 243 ok := object.Key("Type") 244 ok.String(string(v.Type)) 245 } 246 247 return nil 248} 249 250type awsRestjson1_serializeOpCreateRevision struct { 251} 252 253func (*awsRestjson1_serializeOpCreateRevision) ID() string { 254 return "OperationSerializer" 255} 256 257func (m *awsRestjson1_serializeOpCreateRevision) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 258 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 259) { 260 request, ok := in.Request.(*smithyhttp.Request) 261 if !ok { 262 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 263 } 264 265 input, ok := in.Parameters.(*CreateRevisionInput) 266 _ = input 267 if !ok { 268 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 269 } 270 271 opPath, opQuery := httpbinding.SplitURI("/v1/data-sets/{DataSetId}/revisions") 272 request.URL.Path = opPath 273 if len(request.URL.RawQuery) > 0 { 274 request.URL.RawQuery = "&" + opQuery 275 } else { 276 request.URL.RawQuery = opQuery 277 } 278 279 request.Method = "POST" 280 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 281 if err != nil { 282 return out, metadata, &smithy.SerializationError{Err: err} 283 } 284 285 if err := awsRestjson1_serializeOpHttpBindingsCreateRevisionInput(input, restEncoder); err != nil { 286 return out, metadata, &smithy.SerializationError{Err: err} 287 } 288 289 restEncoder.SetHeader("Content-Type").String("application/json") 290 291 jsonEncoder := smithyjson.NewEncoder() 292 if err := awsRestjson1_serializeOpDocumentCreateRevisionInput(input, jsonEncoder.Value); err != nil { 293 return out, metadata, &smithy.SerializationError{Err: err} 294 } 295 296 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 297 return out, metadata, &smithy.SerializationError{Err: err} 298 } 299 300 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 301 return out, metadata, &smithy.SerializationError{Err: err} 302 } 303 in.Request = request 304 305 return next.HandleSerialize(ctx, in) 306} 307func awsRestjson1_serializeOpHttpBindingsCreateRevisionInput(v *CreateRevisionInput, encoder *httpbinding.Encoder) error { 308 if v == nil { 309 return fmt.Errorf("unsupported serialization of nil %T", v) 310 } 311 312 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 313 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 314 } 315 if v.DataSetId != nil { 316 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 317 return err 318 } 319 } 320 321 return nil 322} 323 324func awsRestjson1_serializeOpDocumentCreateRevisionInput(v *CreateRevisionInput, value smithyjson.Value) error { 325 object := value.Object() 326 defer object.Close() 327 328 if v.Comment != nil { 329 ok := object.Key("Comment") 330 ok.String(*v.Comment) 331 } 332 333 if v.Tags != nil { 334 ok := object.Key("Tags") 335 if err := awsRestjson1_serializeDocumentMapOf__string(v.Tags, ok); err != nil { 336 return err 337 } 338 } 339 340 return nil 341} 342 343type awsRestjson1_serializeOpDeleteAsset struct { 344} 345 346func (*awsRestjson1_serializeOpDeleteAsset) ID() string { 347 return "OperationSerializer" 348} 349 350func (m *awsRestjson1_serializeOpDeleteAsset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 351 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 352) { 353 request, ok := in.Request.(*smithyhttp.Request) 354 if !ok { 355 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 356 } 357 358 input, ok := in.Parameters.(*DeleteAssetInput) 359 _ = input 360 if !ok { 361 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 362 } 363 364 opPath, opQuery := httpbinding.SplitURI("/v1/data-sets/{DataSetId}/revisions/{RevisionId}/assets/{AssetId}") 365 request.URL.Path = opPath 366 if len(request.URL.RawQuery) > 0 { 367 request.URL.RawQuery = "&" + opQuery 368 } else { 369 request.URL.RawQuery = opQuery 370 } 371 372 request.Method = "DELETE" 373 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 374 if err != nil { 375 return out, metadata, &smithy.SerializationError{Err: err} 376 } 377 378 if err := awsRestjson1_serializeOpHttpBindingsDeleteAssetInput(input, restEncoder); err != nil { 379 return out, metadata, &smithy.SerializationError{Err: err} 380 } 381 382 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 383 return out, metadata, &smithy.SerializationError{Err: err} 384 } 385 in.Request = request 386 387 return next.HandleSerialize(ctx, in) 388} 389func awsRestjson1_serializeOpHttpBindingsDeleteAssetInput(v *DeleteAssetInput, encoder *httpbinding.Encoder) error { 390 if v == nil { 391 return fmt.Errorf("unsupported serialization of nil %T", v) 392 } 393 394 if v.AssetId == nil || len(*v.AssetId) == 0 { 395 return &smithy.SerializationError{Err: fmt.Errorf("input member AssetId must not be empty")} 396 } 397 if v.AssetId != nil { 398 if err := encoder.SetURI("AssetId").String(*v.AssetId); err != nil { 399 return err 400 } 401 } 402 403 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 404 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 405 } 406 if v.DataSetId != nil { 407 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 408 return err 409 } 410 } 411 412 if v.RevisionId == nil || len(*v.RevisionId) == 0 { 413 return &smithy.SerializationError{Err: fmt.Errorf("input member RevisionId must not be empty")} 414 } 415 if v.RevisionId != nil { 416 if err := encoder.SetURI("RevisionId").String(*v.RevisionId); err != nil { 417 return err 418 } 419 } 420 421 return nil 422} 423 424type awsRestjson1_serializeOpDeleteDataSet struct { 425} 426 427func (*awsRestjson1_serializeOpDeleteDataSet) ID() string { 428 return "OperationSerializer" 429} 430 431func (m *awsRestjson1_serializeOpDeleteDataSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 432 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 433) { 434 request, ok := in.Request.(*smithyhttp.Request) 435 if !ok { 436 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 437 } 438 439 input, ok := in.Parameters.(*DeleteDataSetInput) 440 _ = input 441 if !ok { 442 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 443 } 444 445 opPath, opQuery := httpbinding.SplitURI("/v1/data-sets/{DataSetId}") 446 request.URL.Path = opPath 447 if len(request.URL.RawQuery) > 0 { 448 request.URL.RawQuery = "&" + opQuery 449 } else { 450 request.URL.RawQuery = opQuery 451 } 452 453 request.Method = "DELETE" 454 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 455 if err != nil { 456 return out, metadata, &smithy.SerializationError{Err: err} 457 } 458 459 if err := awsRestjson1_serializeOpHttpBindingsDeleteDataSetInput(input, restEncoder); err != nil { 460 return out, metadata, &smithy.SerializationError{Err: err} 461 } 462 463 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 464 return out, metadata, &smithy.SerializationError{Err: err} 465 } 466 in.Request = request 467 468 return next.HandleSerialize(ctx, in) 469} 470func awsRestjson1_serializeOpHttpBindingsDeleteDataSetInput(v *DeleteDataSetInput, encoder *httpbinding.Encoder) error { 471 if v == nil { 472 return fmt.Errorf("unsupported serialization of nil %T", v) 473 } 474 475 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 476 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 477 } 478 if v.DataSetId != nil { 479 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 480 return err 481 } 482 } 483 484 return nil 485} 486 487type awsRestjson1_serializeOpDeleteRevision struct { 488} 489 490func (*awsRestjson1_serializeOpDeleteRevision) ID() string { 491 return "OperationSerializer" 492} 493 494func (m *awsRestjson1_serializeOpDeleteRevision) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 495 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 496) { 497 request, ok := in.Request.(*smithyhttp.Request) 498 if !ok { 499 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 500 } 501 502 input, ok := in.Parameters.(*DeleteRevisionInput) 503 _ = input 504 if !ok { 505 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 506 } 507 508 opPath, opQuery := httpbinding.SplitURI("/v1/data-sets/{DataSetId}/revisions/{RevisionId}") 509 request.URL.Path = opPath 510 if len(request.URL.RawQuery) > 0 { 511 request.URL.RawQuery = "&" + opQuery 512 } else { 513 request.URL.RawQuery = opQuery 514 } 515 516 request.Method = "DELETE" 517 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 518 if err != nil { 519 return out, metadata, &smithy.SerializationError{Err: err} 520 } 521 522 if err := awsRestjson1_serializeOpHttpBindingsDeleteRevisionInput(input, restEncoder); err != nil { 523 return out, metadata, &smithy.SerializationError{Err: err} 524 } 525 526 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 527 return out, metadata, &smithy.SerializationError{Err: err} 528 } 529 in.Request = request 530 531 return next.HandleSerialize(ctx, in) 532} 533func awsRestjson1_serializeOpHttpBindingsDeleteRevisionInput(v *DeleteRevisionInput, encoder *httpbinding.Encoder) error { 534 if v == nil { 535 return fmt.Errorf("unsupported serialization of nil %T", v) 536 } 537 538 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 539 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 540 } 541 if v.DataSetId != nil { 542 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 543 return err 544 } 545 } 546 547 if v.RevisionId == nil || len(*v.RevisionId) == 0 { 548 return &smithy.SerializationError{Err: fmt.Errorf("input member RevisionId must not be empty")} 549 } 550 if v.RevisionId != nil { 551 if err := encoder.SetURI("RevisionId").String(*v.RevisionId); err != nil { 552 return err 553 } 554 } 555 556 return nil 557} 558 559type awsRestjson1_serializeOpGetAsset struct { 560} 561 562func (*awsRestjson1_serializeOpGetAsset) ID() string { 563 return "OperationSerializer" 564} 565 566func (m *awsRestjson1_serializeOpGetAsset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 567 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 568) { 569 request, ok := in.Request.(*smithyhttp.Request) 570 if !ok { 571 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 572 } 573 574 input, ok := in.Parameters.(*GetAssetInput) 575 _ = input 576 if !ok { 577 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 578 } 579 580 opPath, opQuery := httpbinding.SplitURI("/v1/data-sets/{DataSetId}/revisions/{RevisionId}/assets/{AssetId}") 581 request.URL.Path = opPath 582 if len(request.URL.RawQuery) > 0 { 583 request.URL.RawQuery = "&" + opQuery 584 } else { 585 request.URL.RawQuery = opQuery 586 } 587 588 request.Method = "GET" 589 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 590 if err != nil { 591 return out, metadata, &smithy.SerializationError{Err: err} 592 } 593 594 if err := awsRestjson1_serializeOpHttpBindingsGetAssetInput(input, restEncoder); err != nil { 595 return out, metadata, &smithy.SerializationError{Err: err} 596 } 597 598 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 599 return out, metadata, &smithy.SerializationError{Err: err} 600 } 601 in.Request = request 602 603 return next.HandleSerialize(ctx, in) 604} 605func awsRestjson1_serializeOpHttpBindingsGetAssetInput(v *GetAssetInput, encoder *httpbinding.Encoder) error { 606 if v == nil { 607 return fmt.Errorf("unsupported serialization of nil %T", v) 608 } 609 610 if v.AssetId == nil || len(*v.AssetId) == 0 { 611 return &smithy.SerializationError{Err: fmt.Errorf("input member AssetId must not be empty")} 612 } 613 if v.AssetId != nil { 614 if err := encoder.SetURI("AssetId").String(*v.AssetId); err != nil { 615 return err 616 } 617 } 618 619 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 620 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 621 } 622 if v.DataSetId != nil { 623 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 624 return err 625 } 626 } 627 628 if v.RevisionId == nil || len(*v.RevisionId) == 0 { 629 return &smithy.SerializationError{Err: fmt.Errorf("input member RevisionId must not be empty")} 630 } 631 if v.RevisionId != nil { 632 if err := encoder.SetURI("RevisionId").String(*v.RevisionId); err != nil { 633 return err 634 } 635 } 636 637 return nil 638} 639 640type awsRestjson1_serializeOpGetDataSet struct { 641} 642 643func (*awsRestjson1_serializeOpGetDataSet) ID() string { 644 return "OperationSerializer" 645} 646 647func (m *awsRestjson1_serializeOpGetDataSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 648 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 649) { 650 request, ok := in.Request.(*smithyhttp.Request) 651 if !ok { 652 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 653 } 654 655 input, ok := in.Parameters.(*GetDataSetInput) 656 _ = input 657 if !ok { 658 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 659 } 660 661 opPath, opQuery := httpbinding.SplitURI("/v1/data-sets/{DataSetId}") 662 request.URL.Path = opPath 663 if len(request.URL.RawQuery) > 0 { 664 request.URL.RawQuery = "&" + opQuery 665 } else { 666 request.URL.RawQuery = opQuery 667 } 668 669 request.Method = "GET" 670 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 671 if err != nil { 672 return out, metadata, &smithy.SerializationError{Err: err} 673 } 674 675 if err := awsRestjson1_serializeOpHttpBindingsGetDataSetInput(input, restEncoder); err != nil { 676 return out, metadata, &smithy.SerializationError{Err: err} 677 } 678 679 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 680 return out, metadata, &smithy.SerializationError{Err: err} 681 } 682 in.Request = request 683 684 return next.HandleSerialize(ctx, in) 685} 686func awsRestjson1_serializeOpHttpBindingsGetDataSetInput(v *GetDataSetInput, encoder *httpbinding.Encoder) error { 687 if v == nil { 688 return fmt.Errorf("unsupported serialization of nil %T", v) 689 } 690 691 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 692 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 693 } 694 if v.DataSetId != nil { 695 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 696 return err 697 } 698 } 699 700 return nil 701} 702 703type awsRestjson1_serializeOpGetJob struct { 704} 705 706func (*awsRestjson1_serializeOpGetJob) ID() string { 707 return "OperationSerializer" 708} 709 710func (m *awsRestjson1_serializeOpGetJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 711 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 712) { 713 request, ok := in.Request.(*smithyhttp.Request) 714 if !ok { 715 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 716 } 717 718 input, ok := in.Parameters.(*GetJobInput) 719 _ = input 720 if !ok { 721 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 722 } 723 724 opPath, opQuery := httpbinding.SplitURI("/v1/jobs/{JobId}") 725 request.URL.Path = opPath 726 if len(request.URL.RawQuery) > 0 { 727 request.URL.RawQuery = "&" + opQuery 728 } else { 729 request.URL.RawQuery = opQuery 730 } 731 732 request.Method = "GET" 733 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 734 if err != nil { 735 return out, metadata, &smithy.SerializationError{Err: err} 736 } 737 738 if err := awsRestjson1_serializeOpHttpBindingsGetJobInput(input, restEncoder); err != nil { 739 return out, metadata, &smithy.SerializationError{Err: err} 740 } 741 742 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 743 return out, metadata, &smithy.SerializationError{Err: err} 744 } 745 in.Request = request 746 747 return next.HandleSerialize(ctx, in) 748} 749func awsRestjson1_serializeOpHttpBindingsGetJobInput(v *GetJobInput, encoder *httpbinding.Encoder) error { 750 if v == nil { 751 return fmt.Errorf("unsupported serialization of nil %T", v) 752 } 753 754 if v.JobId == nil || len(*v.JobId) == 0 { 755 return &smithy.SerializationError{Err: fmt.Errorf("input member JobId must not be empty")} 756 } 757 if v.JobId != nil { 758 if err := encoder.SetURI("JobId").String(*v.JobId); err != nil { 759 return err 760 } 761 } 762 763 return nil 764} 765 766type awsRestjson1_serializeOpGetRevision struct { 767} 768 769func (*awsRestjson1_serializeOpGetRevision) ID() string { 770 return "OperationSerializer" 771} 772 773func (m *awsRestjson1_serializeOpGetRevision) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 774 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 775) { 776 request, ok := in.Request.(*smithyhttp.Request) 777 if !ok { 778 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 779 } 780 781 input, ok := in.Parameters.(*GetRevisionInput) 782 _ = input 783 if !ok { 784 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 785 } 786 787 opPath, opQuery := httpbinding.SplitURI("/v1/data-sets/{DataSetId}/revisions/{RevisionId}") 788 request.URL.Path = opPath 789 if len(request.URL.RawQuery) > 0 { 790 request.URL.RawQuery = "&" + opQuery 791 } else { 792 request.URL.RawQuery = opQuery 793 } 794 795 request.Method = "GET" 796 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 797 if err != nil { 798 return out, metadata, &smithy.SerializationError{Err: err} 799 } 800 801 if err := awsRestjson1_serializeOpHttpBindingsGetRevisionInput(input, restEncoder); err != nil { 802 return out, metadata, &smithy.SerializationError{Err: err} 803 } 804 805 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 806 return out, metadata, &smithy.SerializationError{Err: err} 807 } 808 in.Request = request 809 810 return next.HandleSerialize(ctx, in) 811} 812func awsRestjson1_serializeOpHttpBindingsGetRevisionInput(v *GetRevisionInput, encoder *httpbinding.Encoder) error { 813 if v == nil { 814 return fmt.Errorf("unsupported serialization of nil %T", v) 815 } 816 817 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 818 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 819 } 820 if v.DataSetId != nil { 821 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 822 return err 823 } 824 } 825 826 if v.RevisionId == nil || len(*v.RevisionId) == 0 { 827 return &smithy.SerializationError{Err: fmt.Errorf("input member RevisionId must not be empty")} 828 } 829 if v.RevisionId != nil { 830 if err := encoder.SetURI("RevisionId").String(*v.RevisionId); err != nil { 831 return err 832 } 833 } 834 835 return nil 836} 837 838type awsRestjson1_serializeOpListDataSetRevisions struct { 839} 840 841func (*awsRestjson1_serializeOpListDataSetRevisions) ID() string { 842 return "OperationSerializer" 843} 844 845func (m *awsRestjson1_serializeOpListDataSetRevisions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 846 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 847) { 848 request, ok := in.Request.(*smithyhttp.Request) 849 if !ok { 850 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 851 } 852 853 input, ok := in.Parameters.(*ListDataSetRevisionsInput) 854 _ = input 855 if !ok { 856 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 857 } 858 859 opPath, opQuery := httpbinding.SplitURI("/v1/data-sets/{DataSetId}/revisions") 860 request.URL.Path = opPath 861 if len(request.URL.RawQuery) > 0 { 862 request.URL.RawQuery = "&" + opQuery 863 } else { 864 request.URL.RawQuery = opQuery 865 } 866 867 request.Method = "GET" 868 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 869 if err != nil { 870 return out, metadata, &smithy.SerializationError{Err: err} 871 } 872 873 if err := awsRestjson1_serializeOpHttpBindingsListDataSetRevisionsInput(input, restEncoder); err != nil { 874 return out, metadata, &smithy.SerializationError{Err: err} 875 } 876 877 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 878 return out, metadata, &smithy.SerializationError{Err: err} 879 } 880 in.Request = request 881 882 return next.HandleSerialize(ctx, in) 883} 884func awsRestjson1_serializeOpHttpBindingsListDataSetRevisionsInput(v *ListDataSetRevisionsInput, encoder *httpbinding.Encoder) error { 885 if v == nil { 886 return fmt.Errorf("unsupported serialization of nil %T", v) 887 } 888 889 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 890 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 891 } 892 if v.DataSetId != nil { 893 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 894 return err 895 } 896 } 897 898 if v.MaxResults != 0 { 899 encoder.SetQuery("maxResults").Integer(v.MaxResults) 900 } 901 902 if v.NextToken != nil { 903 encoder.SetQuery("nextToken").String(*v.NextToken) 904 } 905 906 return nil 907} 908 909type awsRestjson1_serializeOpListDataSets struct { 910} 911 912func (*awsRestjson1_serializeOpListDataSets) ID() string { 913 return "OperationSerializer" 914} 915 916func (m *awsRestjson1_serializeOpListDataSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 917 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 918) { 919 request, ok := in.Request.(*smithyhttp.Request) 920 if !ok { 921 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 922 } 923 924 input, ok := in.Parameters.(*ListDataSetsInput) 925 _ = input 926 if !ok { 927 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 928 } 929 930 opPath, opQuery := httpbinding.SplitURI("/v1/data-sets") 931 request.URL.Path = opPath 932 if len(request.URL.RawQuery) > 0 { 933 request.URL.RawQuery = "&" + opQuery 934 } else { 935 request.URL.RawQuery = opQuery 936 } 937 938 request.Method = "GET" 939 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 940 if err != nil { 941 return out, metadata, &smithy.SerializationError{Err: err} 942 } 943 944 if err := awsRestjson1_serializeOpHttpBindingsListDataSetsInput(input, restEncoder); err != nil { 945 return out, metadata, &smithy.SerializationError{Err: err} 946 } 947 948 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 949 return out, metadata, &smithy.SerializationError{Err: err} 950 } 951 in.Request = request 952 953 return next.HandleSerialize(ctx, in) 954} 955func awsRestjson1_serializeOpHttpBindingsListDataSetsInput(v *ListDataSetsInput, encoder *httpbinding.Encoder) error { 956 if v == nil { 957 return fmt.Errorf("unsupported serialization of nil %T", v) 958 } 959 960 if v.MaxResults != 0 { 961 encoder.SetQuery("maxResults").Integer(v.MaxResults) 962 } 963 964 if v.NextToken != nil { 965 encoder.SetQuery("nextToken").String(*v.NextToken) 966 } 967 968 if v.Origin != nil { 969 encoder.SetQuery("origin").String(*v.Origin) 970 } 971 972 return nil 973} 974 975type awsRestjson1_serializeOpListJobs struct { 976} 977 978func (*awsRestjson1_serializeOpListJobs) ID() string { 979 return "OperationSerializer" 980} 981 982func (m *awsRestjson1_serializeOpListJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 983 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 984) { 985 request, ok := in.Request.(*smithyhttp.Request) 986 if !ok { 987 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 988 } 989 990 input, ok := in.Parameters.(*ListJobsInput) 991 _ = input 992 if !ok { 993 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 994 } 995 996 opPath, opQuery := httpbinding.SplitURI("/v1/jobs") 997 request.URL.Path = opPath 998 if len(request.URL.RawQuery) > 0 { 999 request.URL.RawQuery = "&" + opQuery 1000 } else { 1001 request.URL.RawQuery = opQuery 1002 } 1003 1004 request.Method = "GET" 1005 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1006 if err != nil { 1007 return out, metadata, &smithy.SerializationError{Err: err} 1008 } 1009 1010 if err := awsRestjson1_serializeOpHttpBindingsListJobsInput(input, restEncoder); err != nil { 1011 return out, metadata, &smithy.SerializationError{Err: err} 1012 } 1013 1014 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1015 return out, metadata, &smithy.SerializationError{Err: err} 1016 } 1017 in.Request = request 1018 1019 return next.HandleSerialize(ctx, in) 1020} 1021func awsRestjson1_serializeOpHttpBindingsListJobsInput(v *ListJobsInput, encoder *httpbinding.Encoder) error { 1022 if v == nil { 1023 return fmt.Errorf("unsupported serialization of nil %T", v) 1024 } 1025 1026 if v.DataSetId != nil { 1027 encoder.SetQuery("dataSetId").String(*v.DataSetId) 1028 } 1029 1030 if v.MaxResults != 0 { 1031 encoder.SetQuery("maxResults").Integer(v.MaxResults) 1032 } 1033 1034 if v.NextToken != nil { 1035 encoder.SetQuery("nextToken").String(*v.NextToken) 1036 } 1037 1038 if v.RevisionId != nil { 1039 encoder.SetQuery("revisionId").String(*v.RevisionId) 1040 } 1041 1042 return nil 1043} 1044 1045type awsRestjson1_serializeOpListRevisionAssets struct { 1046} 1047 1048func (*awsRestjson1_serializeOpListRevisionAssets) ID() string { 1049 return "OperationSerializer" 1050} 1051 1052func (m *awsRestjson1_serializeOpListRevisionAssets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1053 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1054) { 1055 request, ok := in.Request.(*smithyhttp.Request) 1056 if !ok { 1057 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1058 } 1059 1060 input, ok := in.Parameters.(*ListRevisionAssetsInput) 1061 _ = input 1062 if !ok { 1063 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1064 } 1065 1066 opPath, opQuery := httpbinding.SplitURI("/v1/data-sets/{DataSetId}/revisions/{RevisionId}/assets") 1067 request.URL.Path = opPath 1068 if len(request.URL.RawQuery) > 0 { 1069 request.URL.RawQuery = "&" + opQuery 1070 } else { 1071 request.URL.RawQuery = opQuery 1072 } 1073 1074 request.Method = "GET" 1075 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1076 if err != nil { 1077 return out, metadata, &smithy.SerializationError{Err: err} 1078 } 1079 1080 if err := awsRestjson1_serializeOpHttpBindingsListRevisionAssetsInput(input, restEncoder); err != nil { 1081 return out, metadata, &smithy.SerializationError{Err: err} 1082 } 1083 1084 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1085 return out, metadata, &smithy.SerializationError{Err: err} 1086 } 1087 in.Request = request 1088 1089 return next.HandleSerialize(ctx, in) 1090} 1091func awsRestjson1_serializeOpHttpBindingsListRevisionAssetsInput(v *ListRevisionAssetsInput, encoder *httpbinding.Encoder) error { 1092 if v == nil { 1093 return fmt.Errorf("unsupported serialization of nil %T", v) 1094 } 1095 1096 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 1097 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 1098 } 1099 if v.DataSetId != nil { 1100 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 1101 return err 1102 } 1103 } 1104 1105 if v.MaxResults != 0 { 1106 encoder.SetQuery("maxResults").Integer(v.MaxResults) 1107 } 1108 1109 if v.NextToken != nil { 1110 encoder.SetQuery("nextToken").String(*v.NextToken) 1111 } 1112 1113 if v.RevisionId == nil || len(*v.RevisionId) == 0 { 1114 return &smithy.SerializationError{Err: fmt.Errorf("input member RevisionId must not be empty")} 1115 } 1116 if v.RevisionId != nil { 1117 if err := encoder.SetURI("RevisionId").String(*v.RevisionId); err != nil { 1118 return err 1119 } 1120 } 1121 1122 return nil 1123} 1124 1125type awsRestjson1_serializeOpListTagsForResource struct { 1126} 1127 1128func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 1129 return "OperationSerializer" 1130} 1131 1132func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1133 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1134) { 1135 request, ok := in.Request.(*smithyhttp.Request) 1136 if !ok { 1137 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1138 } 1139 1140 input, ok := in.Parameters.(*ListTagsForResourceInput) 1141 _ = input 1142 if !ok { 1143 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1144 } 1145 1146 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 1147 request.URL.Path = opPath 1148 if len(request.URL.RawQuery) > 0 { 1149 request.URL.RawQuery = "&" + opQuery 1150 } else { 1151 request.URL.RawQuery = opQuery 1152 } 1153 1154 request.Method = "GET" 1155 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1156 if err != nil { 1157 return out, metadata, &smithy.SerializationError{Err: err} 1158 } 1159 1160 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 1161 return out, metadata, &smithy.SerializationError{Err: err} 1162 } 1163 1164 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1165 return out, metadata, &smithy.SerializationError{Err: err} 1166 } 1167 in.Request = request 1168 1169 return next.HandleSerialize(ctx, in) 1170} 1171func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 1172 if v == nil { 1173 return fmt.Errorf("unsupported serialization of nil %T", v) 1174 } 1175 1176 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1177 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 1178 } 1179 if v.ResourceArn != nil { 1180 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 1181 return err 1182 } 1183 } 1184 1185 return nil 1186} 1187 1188type awsRestjson1_serializeOpStartJob struct { 1189} 1190 1191func (*awsRestjson1_serializeOpStartJob) ID() string { 1192 return "OperationSerializer" 1193} 1194 1195func (m *awsRestjson1_serializeOpStartJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1196 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1197) { 1198 request, ok := in.Request.(*smithyhttp.Request) 1199 if !ok { 1200 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1201 } 1202 1203 input, ok := in.Parameters.(*StartJobInput) 1204 _ = input 1205 if !ok { 1206 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1207 } 1208 1209 opPath, opQuery := httpbinding.SplitURI("/v1/jobs/{JobId}") 1210 request.URL.Path = opPath 1211 if len(request.URL.RawQuery) > 0 { 1212 request.URL.RawQuery = "&" + opQuery 1213 } else { 1214 request.URL.RawQuery = opQuery 1215 } 1216 1217 request.Method = "PATCH" 1218 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1219 if err != nil { 1220 return out, metadata, &smithy.SerializationError{Err: err} 1221 } 1222 1223 if err := awsRestjson1_serializeOpHttpBindingsStartJobInput(input, restEncoder); err != nil { 1224 return out, metadata, &smithy.SerializationError{Err: err} 1225 } 1226 1227 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1228 return out, metadata, &smithy.SerializationError{Err: err} 1229 } 1230 in.Request = request 1231 1232 return next.HandleSerialize(ctx, in) 1233} 1234func awsRestjson1_serializeOpHttpBindingsStartJobInput(v *StartJobInput, encoder *httpbinding.Encoder) error { 1235 if v == nil { 1236 return fmt.Errorf("unsupported serialization of nil %T", v) 1237 } 1238 1239 if v.JobId == nil || len(*v.JobId) == 0 { 1240 return &smithy.SerializationError{Err: fmt.Errorf("input member JobId must not be empty")} 1241 } 1242 if v.JobId != nil { 1243 if err := encoder.SetURI("JobId").String(*v.JobId); err != nil { 1244 return err 1245 } 1246 } 1247 1248 return nil 1249} 1250 1251type awsRestjson1_serializeOpTagResource struct { 1252} 1253 1254func (*awsRestjson1_serializeOpTagResource) ID() string { 1255 return "OperationSerializer" 1256} 1257 1258func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1259 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1260) { 1261 request, ok := in.Request.(*smithyhttp.Request) 1262 if !ok { 1263 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1264 } 1265 1266 input, ok := in.Parameters.(*TagResourceInput) 1267 _ = input 1268 if !ok { 1269 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1270 } 1271 1272 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 1273 request.URL.Path = opPath 1274 if len(request.URL.RawQuery) > 0 { 1275 request.URL.RawQuery = "&" + opQuery 1276 } else { 1277 request.URL.RawQuery = opQuery 1278 } 1279 1280 request.Method = "POST" 1281 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1282 if err != nil { 1283 return out, metadata, &smithy.SerializationError{Err: err} 1284 } 1285 1286 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 1287 return out, metadata, &smithy.SerializationError{Err: err} 1288 } 1289 1290 restEncoder.SetHeader("Content-Type").String("application/json") 1291 1292 jsonEncoder := smithyjson.NewEncoder() 1293 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 1294 return out, metadata, &smithy.SerializationError{Err: err} 1295 } 1296 1297 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1298 return out, metadata, &smithy.SerializationError{Err: err} 1299 } 1300 1301 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1302 return out, metadata, &smithy.SerializationError{Err: err} 1303 } 1304 in.Request = request 1305 1306 return next.HandleSerialize(ctx, in) 1307} 1308func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 1309 if v == nil { 1310 return fmt.Errorf("unsupported serialization of nil %T", v) 1311 } 1312 1313 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1314 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 1315 } 1316 if v.ResourceArn != nil { 1317 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 1318 return err 1319 } 1320 } 1321 1322 return nil 1323} 1324 1325func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 1326 object := value.Object() 1327 defer object.Close() 1328 1329 if v.Tags != nil { 1330 ok := object.Key("tags") 1331 if err := awsRestjson1_serializeDocumentMapOf__string(v.Tags, ok); err != nil { 1332 return err 1333 } 1334 } 1335 1336 return nil 1337} 1338 1339type awsRestjson1_serializeOpUntagResource struct { 1340} 1341 1342func (*awsRestjson1_serializeOpUntagResource) ID() string { 1343 return "OperationSerializer" 1344} 1345 1346func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1347 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1348) { 1349 request, ok := in.Request.(*smithyhttp.Request) 1350 if !ok { 1351 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1352 } 1353 1354 input, ok := in.Parameters.(*UntagResourceInput) 1355 _ = input 1356 if !ok { 1357 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1358 } 1359 1360 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 1361 request.URL.Path = opPath 1362 if len(request.URL.RawQuery) > 0 { 1363 request.URL.RawQuery = "&" + opQuery 1364 } else { 1365 request.URL.RawQuery = opQuery 1366 } 1367 1368 request.Method = "DELETE" 1369 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1370 if err != nil { 1371 return out, metadata, &smithy.SerializationError{Err: err} 1372 } 1373 1374 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 1375 return out, metadata, &smithy.SerializationError{Err: err} 1376 } 1377 1378 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1379 return out, metadata, &smithy.SerializationError{Err: err} 1380 } 1381 in.Request = request 1382 1383 return next.HandleSerialize(ctx, in) 1384} 1385func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 1386 if v == nil { 1387 return fmt.Errorf("unsupported serialization of nil %T", v) 1388 } 1389 1390 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1391 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 1392 } 1393 if v.ResourceArn != nil { 1394 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 1395 return err 1396 } 1397 } 1398 1399 if v.TagKeys != nil { 1400 for i := range v.TagKeys { 1401 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 1402 } 1403 } 1404 1405 return nil 1406} 1407 1408type awsRestjson1_serializeOpUpdateAsset struct { 1409} 1410 1411func (*awsRestjson1_serializeOpUpdateAsset) ID() string { 1412 return "OperationSerializer" 1413} 1414 1415func (m *awsRestjson1_serializeOpUpdateAsset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1416 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1417) { 1418 request, ok := in.Request.(*smithyhttp.Request) 1419 if !ok { 1420 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1421 } 1422 1423 input, ok := in.Parameters.(*UpdateAssetInput) 1424 _ = input 1425 if !ok { 1426 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1427 } 1428 1429 opPath, opQuery := httpbinding.SplitURI("/v1/data-sets/{DataSetId}/revisions/{RevisionId}/assets/{AssetId}") 1430 request.URL.Path = opPath 1431 if len(request.URL.RawQuery) > 0 { 1432 request.URL.RawQuery = "&" + opQuery 1433 } else { 1434 request.URL.RawQuery = opQuery 1435 } 1436 1437 request.Method = "PATCH" 1438 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1439 if err != nil { 1440 return out, metadata, &smithy.SerializationError{Err: err} 1441 } 1442 1443 if err := awsRestjson1_serializeOpHttpBindingsUpdateAssetInput(input, restEncoder); err != nil { 1444 return out, metadata, &smithy.SerializationError{Err: err} 1445 } 1446 1447 restEncoder.SetHeader("Content-Type").String("application/json") 1448 1449 jsonEncoder := smithyjson.NewEncoder() 1450 if err := awsRestjson1_serializeOpDocumentUpdateAssetInput(input, jsonEncoder.Value); err != nil { 1451 return out, metadata, &smithy.SerializationError{Err: err} 1452 } 1453 1454 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1455 return out, metadata, &smithy.SerializationError{Err: err} 1456 } 1457 1458 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1459 return out, metadata, &smithy.SerializationError{Err: err} 1460 } 1461 in.Request = request 1462 1463 return next.HandleSerialize(ctx, in) 1464} 1465func awsRestjson1_serializeOpHttpBindingsUpdateAssetInput(v *UpdateAssetInput, encoder *httpbinding.Encoder) error { 1466 if v == nil { 1467 return fmt.Errorf("unsupported serialization of nil %T", v) 1468 } 1469 1470 if v.AssetId == nil || len(*v.AssetId) == 0 { 1471 return &smithy.SerializationError{Err: fmt.Errorf("input member AssetId must not be empty")} 1472 } 1473 if v.AssetId != nil { 1474 if err := encoder.SetURI("AssetId").String(*v.AssetId); err != nil { 1475 return err 1476 } 1477 } 1478 1479 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 1480 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 1481 } 1482 if v.DataSetId != nil { 1483 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 1484 return err 1485 } 1486 } 1487 1488 if v.RevisionId == nil || len(*v.RevisionId) == 0 { 1489 return &smithy.SerializationError{Err: fmt.Errorf("input member RevisionId must not be empty")} 1490 } 1491 if v.RevisionId != nil { 1492 if err := encoder.SetURI("RevisionId").String(*v.RevisionId); err != nil { 1493 return err 1494 } 1495 } 1496 1497 return nil 1498} 1499 1500func awsRestjson1_serializeOpDocumentUpdateAssetInput(v *UpdateAssetInput, value smithyjson.Value) error { 1501 object := value.Object() 1502 defer object.Close() 1503 1504 if v.Name != nil { 1505 ok := object.Key("Name") 1506 ok.String(*v.Name) 1507 } 1508 1509 return nil 1510} 1511 1512type awsRestjson1_serializeOpUpdateDataSet struct { 1513} 1514 1515func (*awsRestjson1_serializeOpUpdateDataSet) ID() string { 1516 return "OperationSerializer" 1517} 1518 1519func (m *awsRestjson1_serializeOpUpdateDataSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1520 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1521) { 1522 request, ok := in.Request.(*smithyhttp.Request) 1523 if !ok { 1524 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1525 } 1526 1527 input, ok := in.Parameters.(*UpdateDataSetInput) 1528 _ = input 1529 if !ok { 1530 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1531 } 1532 1533 opPath, opQuery := httpbinding.SplitURI("/v1/data-sets/{DataSetId}") 1534 request.URL.Path = opPath 1535 if len(request.URL.RawQuery) > 0 { 1536 request.URL.RawQuery = "&" + opQuery 1537 } else { 1538 request.URL.RawQuery = opQuery 1539 } 1540 1541 request.Method = "PATCH" 1542 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1543 if err != nil { 1544 return out, metadata, &smithy.SerializationError{Err: err} 1545 } 1546 1547 if err := awsRestjson1_serializeOpHttpBindingsUpdateDataSetInput(input, restEncoder); err != nil { 1548 return out, metadata, &smithy.SerializationError{Err: err} 1549 } 1550 1551 restEncoder.SetHeader("Content-Type").String("application/json") 1552 1553 jsonEncoder := smithyjson.NewEncoder() 1554 if err := awsRestjson1_serializeOpDocumentUpdateDataSetInput(input, jsonEncoder.Value); err != nil { 1555 return out, metadata, &smithy.SerializationError{Err: err} 1556 } 1557 1558 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1559 return out, metadata, &smithy.SerializationError{Err: err} 1560 } 1561 1562 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1563 return out, metadata, &smithy.SerializationError{Err: err} 1564 } 1565 in.Request = request 1566 1567 return next.HandleSerialize(ctx, in) 1568} 1569func awsRestjson1_serializeOpHttpBindingsUpdateDataSetInput(v *UpdateDataSetInput, encoder *httpbinding.Encoder) error { 1570 if v == nil { 1571 return fmt.Errorf("unsupported serialization of nil %T", v) 1572 } 1573 1574 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 1575 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 1576 } 1577 if v.DataSetId != nil { 1578 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 1579 return err 1580 } 1581 } 1582 1583 return nil 1584} 1585 1586func awsRestjson1_serializeOpDocumentUpdateDataSetInput(v *UpdateDataSetInput, value smithyjson.Value) error { 1587 object := value.Object() 1588 defer object.Close() 1589 1590 if v.Description != nil { 1591 ok := object.Key("Description") 1592 ok.String(*v.Description) 1593 } 1594 1595 if v.Name != nil { 1596 ok := object.Key("Name") 1597 ok.String(*v.Name) 1598 } 1599 1600 return nil 1601} 1602 1603type awsRestjson1_serializeOpUpdateRevision struct { 1604} 1605 1606func (*awsRestjson1_serializeOpUpdateRevision) ID() string { 1607 return "OperationSerializer" 1608} 1609 1610func (m *awsRestjson1_serializeOpUpdateRevision) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1611 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1612) { 1613 request, ok := in.Request.(*smithyhttp.Request) 1614 if !ok { 1615 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1616 } 1617 1618 input, ok := in.Parameters.(*UpdateRevisionInput) 1619 _ = input 1620 if !ok { 1621 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1622 } 1623 1624 opPath, opQuery := httpbinding.SplitURI("/v1/data-sets/{DataSetId}/revisions/{RevisionId}") 1625 request.URL.Path = opPath 1626 if len(request.URL.RawQuery) > 0 { 1627 request.URL.RawQuery = "&" + opQuery 1628 } else { 1629 request.URL.RawQuery = opQuery 1630 } 1631 1632 request.Method = "PATCH" 1633 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1634 if err != nil { 1635 return out, metadata, &smithy.SerializationError{Err: err} 1636 } 1637 1638 if err := awsRestjson1_serializeOpHttpBindingsUpdateRevisionInput(input, restEncoder); err != nil { 1639 return out, metadata, &smithy.SerializationError{Err: err} 1640 } 1641 1642 restEncoder.SetHeader("Content-Type").String("application/json") 1643 1644 jsonEncoder := smithyjson.NewEncoder() 1645 if err := awsRestjson1_serializeOpDocumentUpdateRevisionInput(input, jsonEncoder.Value); err != nil { 1646 return out, metadata, &smithy.SerializationError{Err: err} 1647 } 1648 1649 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1650 return out, metadata, &smithy.SerializationError{Err: err} 1651 } 1652 1653 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1654 return out, metadata, &smithy.SerializationError{Err: err} 1655 } 1656 in.Request = request 1657 1658 return next.HandleSerialize(ctx, in) 1659} 1660func awsRestjson1_serializeOpHttpBindingsUpdateRevisionInput(v *UpdateRevisionInput, encoder *httpbinding.Encoder) error { 1661 if v == nil { 1662 return fmt.Errorf("unsupported serialization of nil %T", v) 1663 } 1664 1665 if v.DataSetId == nil || len(*v.DataSetId) == 0 { 1666 return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")} 1667 } 1668 if v.DataSetId != nil { 1669 if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil { 1670 return err 1671 } 1672 } 1673 1674 if v.RevisionId == nil || len(*v.RevisionId) == 0 { 1675 return &smithy.SerializationError{Err: fmt.Errorf("input member RevisionId must not be empty")} 1676 } 1677 if v.RevisionId != nil { 1678 if err := encoder.SetURI("RevisionId").String(*v.RevisionId); err != nil { 1679 return err 1680 } 1681 } 1682 1683 return nil 1684} 1685 1686func awsRestjson1_serializeOpDocumentUpdateRevisionInput(v *UpdateRevisionInput, value smithyjson.Value) error { 1687 object := value.Object() 1688 defer object.Close() 1689 1690 if v.Comment != nil { 1691 ok := object.Key("Comment") 1692 ok.String(*v.Comment) 1693 } 1694 1695 if v.Finalized { 1696 ok := object.Key("Finalized") 1697 ok.Boolean(v.Finalized) 1698 } 1699 1700 return nil 1701} 1702 1703func awsRestjson1_serializeDocumentAssetDestinationEntry(v *types.AssetDestinationEntry, value smithyjson.Value) error { 1704 object := value.Object() 1705 defer object.Close() 1706 1707 if v.AssetId != nil { 1708 ok := object.Key("AssetId") 1709 ok.String(*v.AssetId) 1710 } 1711 1712 if v.Bucket != nil { 1713 ok := object.Key("Bucket") 1714 ok.String(*v.Bucket) 1715 } 1716 1717 if v.Key != nil { 1718 ok := object.Key("Key") 1719 ok.String(*v.Key) 1720 } 1721 1722 return nil 1723} 1724 1725func awsRestjson1_serializeDocumentAssetSourceEntry(v *types.AssetSourceEntry, value smithyjson.Value) error { 1726 object := value.Object() 1727 defer object.Close() 1728 1729 if v.Bucket != nil { 1730 ok := object.Key("Bucket") 1731 ok.String(*v.Bucket) 1732 } 1733 1734 if v.Key != nil { 1735 ok := object.Key("Key") 1736 ok.String(*v.Key) 1737 } 1738 1739 return nil 1740} 1741 1742func awsRestjson1_serializeDocumentExportAssetsToS3RequestDetails(v *types.ExportAssetsToS3RequestDetails, value smithyjson.Value) error { 1743 object := value.Object() 1744 defer object.Close() 1745 1746 if v.AssetDestinations != nil { 1747 ok := object.Key("AssetDestinations") 1748 if err := awsRestjson1_serializeDocumentListOfAssetDestinationEntry(v.AssetDestinations, ok); err != nil { 1749 return err 1750 } 1751 } 1752 1753 if v.DataSetId != nil { 1754 ok := object.Key("DataSetId") 1755 ok.String(*v.DataSetId) 1756 } 1757 1758 if v.Encryption != nil { 1759 ok := object.Key("Encryption") 1760 if err := awsRestjson1_serializeDocumentExportServerSideEncryption(v.Encryption, ok); err != nil { 1761 return err 1762 } 1763 } 1764 1765 if v.RevisionId != nil { 1766 ok := object.Key("RevisionId") 1767 ok.String(*v.RevisionId) 1768 } 1769 1770 return nil 1771} 1772 1773func awsRestjson1_serializeDocumentExportAssetToSignedUrlRequestDetails(v *types.ExportAssetToSignedUrlRequestDetails, value smithyjson.Value) error { 1774 object := value.Object() 1775 defer object.Close() 1776 1777 if v.AssetId != nil { 1778 ok := object.Key("AssetId") 1779 ok.String(*v.AssetId) 1780 } 1781 1782 if v.DataSetId != nil { 1783 ok := object.Key("DataSetId") 1784 ok.String(*v.DataSetId) 1785 } 1786 1787 if v.RevisionId != nil { 1788 ok := object.Key("RevisionId") 1789 ok.String(*v.RevisionId) 1790 } 1791 1792 return nil 1793} 1794 1795func awsRestjson1_serializeDocumentExportServerSideEncryption(v *types.ExportServerSideEncryption, value smithyjson.Value) error { 1796 object := value.Object() 1797 defer object.Close() 1798 1799 if v.KmsKeyArn != nil { 1800 ok := object.Key("KmsKeyArn") 1801 ok.String(*v.KmsKeyArn) 1802 } 1803 1804 if len(v.Type) > 0 { 1805 ok := object.Key("Type") 1806 ok.String(string(v.Type)) 1807 } 1808 1809 return nil 1810} 1811 1812func awsRestjson1_serializeDocumentImportAssetFromSignedUrlRequestDetails(v *types.ImportAssetFromSignedUrlRequestDetails, value smithyjson.Value) error { 1813 object := value.Object() 1814 defer object.Close() 1815 1816 if v.AssetName != nil { 1817 ok := object.Key("AssetName") 1818 ok.String(*v.AssetName) 1819 } 1820 1821 if v.DataSetId != nil { 1822 ok := object.Key("DataSetId") 1823 ok.String(*v.DataSetId) 1824 } 1825 1826 if v.Md5Hash != nil { 1827 ok := object.Key("Md5Hash") 1828 ok.String(*v.Md5Hash) 1829 } 1830 1831 if v.RevisionId != nil { 1832 ok := object.Key("RevisionId") 1833 ok.String(*v.RevisionId) 1834 } 1835 1836 return nil 1837} 1838 1839func awsRestjson1_serializeDocumentImportAssetsFromS3RequestDetails(v *types.ImportAssetsFromS3RequestDetails, value smithyjson.Value) error { 1840 object := value.Object() 1841 defer object.Close() 1842 1843 if v.AssetSources != nil { 1844 ok := object.Key("AssetSources") 1845 if err := awsRestjson1_serializeDocumentListOfAssetSourceEntry(v.AssetSources, ok); err != nil { 1846 return err 1847 } 1848 } 1849 1850 if v.DataSetId != nil { 1851 ok := object.Key("DataSetId") 1852 ok.String(*v.DataSetId) 1853 } 1854 1855 if v.RevisionId != nil { 1856 ok := object.Key("RevisionId") 1857 ok.String(*v.RevisionId) 1858 } 1859 1860 return nil 1861} 1862 1863func awsRestjson1_serializeDocumentListOfAssetDestinationEntry(v []types.AssetDestinationEntry, value smithyjson.Value) error { 1864 array := value.Array() 1865 defer array.Close() 1866 1867 for i := range v { 1868 av := array.Value() 1869 if err := awsRestjson1_serializeDocumentAssetDestinationEntry(&v[i], av); err != nil { 1870 return err 1871 } 1872 } 1873 return nil 1874} 1875 1876func awsRestjson1_serializeDocumentListOfAssetSourceEntry(v []types.AssetSourceEntry, value smithyjson.Value) error { 1877 array := value.Array() 1878 defer array.Close() 1879 1880 for i := range v { 1881 av := array.Value() 1882 if err := awsRestjson1_serializeDocumentAssetSourceEntry(&v[i], av); err != nil { 1883 return err 1884 } 1885 } 1886 return nil 1887} 1888 1889func awsRestjson1_serializeDocumentMapOf__string(v map[string]string, value smithyjson.Value) error { 1890 object := value.Object() 1891 defer object.Close() 1892 1893 for key := range v { 1894 om := object.Key(key) 1895 om.String(v[key]) 1896 } 1897 return nil 1898} 1899 1900func awsRestjson1_serializeDocumentRequestDetails(v *types.RequestDetails, value smithyjson.Value) error { 1901 object := value.Object() 1902 defer object.Close() 1903 1904 if v.ExportAssetsToS3 != nil { 1905 ok := object.Key("ExportAssetsToS3") 1906 if err := awsRestjson1_serializeDocumentExportAssetsToS3RequestDetails(v.ExportAssetsToS3, ok); err != nil { 1907 return err 1908 } 1909 } 1910 1911 if v.ExportAssetToSignedUrl != nil { 1912 ok := object.Key("ExportAssetToSignedUrl") 1913 if err := awsRestjson1_serializeDocumentExportAssetToSignedUrlRequestDetails(v.ExportAssetToSignedUrl, ok); err != nil { 1914 return err 1915 } 1916 } 1917 1918 if v.ImportAssetFromSignedUrl != nil { 1919 ok := object.Key("ImportAssetFromSignedUrl") 1920 if err := awsRestjson1_serializeDocumentImportAssetFromSignedUrlRequestDetails(v.ImportAssetFromSignedUrl, ok); err != nil { 1921 return err 1922 } 1923 } 1924 1925 if v.ImportAssetsFromS3 != nil { 1926 ok := object.Key("ImportAssetsFromS3") 1927 if err := awsRestjson1_serializeDocumentImportAssetsFromS3RequestDetails(v.ImportAssetsFromS3, ok); err != nil { 1928 return err 1929 } 1930 } 1931 1932 return nil 1933} 1934