1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package databrew 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/databrew/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_serializeOpBatchDeleteRecipeVersion struct { 18} 19 20func (*awsRestjson1_serializeOpBatchDeleteRecipeVersion) ID() string { 21 return "OperationSerializer" 22} 23 24func (m *awsRestjson1_serializeOpBatchDeleteRecipeVersion) 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.(*BatchDeleteRecipeVersionInput) 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("/recipes/{Name}/batchDeleteRecipeVersion") 39 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 40 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 41 request.Method = "POST" 42 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 43 if err != nil { 44 return out, metadata, &smithy.SerializationError{Err: err} 45 } 46 47 if err := awsRestjson1_serializeOpHttpBindingsBatchDeleteRecipeVersionInput(input, restEncoder); err != nil { 48 return out, metadata, &smithy.SerializationError{Err: err} 49 } 50 51 restEncoder.SetHeader("Content-Type").String("application/json") 52 53 jsonEncoder := smithyjson.NewEncoder() 54 if err := awsRestjson1_serializeOpDocumentBatchDeleteRecipeVersionInput(input, jsonEncoder.Value); err != nil { 55 return out, metadata, &smithy.SerializationError{Err: err} 56 } 57 58 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 59 return out, metadata, &smithy.SerializationError{Err: err} 60 } 61 62 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 63 return out, metadata, &smithy.SerializationError{Err: err} 64 } 65 in.Request = request 66 67 return next.HandleSerialize(ctx, in) 68} 69func awsRestjson1_serializeOpHttpBindingsBatchDeleteRecipeVersionInput(v *BatchDeleteRecipeVersionInput, encoder *httpbinding.Encoder) error { 70 if v == nil { 71 return fmt.Errorf("unsupported serialization of nil %T", v) 72 } 73 74 if v.Name == nil || len(*v.Name) == 0 { 75 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 76 } 77 if v.Name != nil { 78 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 79 return err 80 } 81 } 82 83 return nil 84} 85 86func awsRestjson1_serializeOpDocumentBatchDeleteRecipeVersionInput(v *BatchDeleteRecipeVersionInput, value smithyjson.Value) error { 87 object := value.Object() 88 defer object.Close() 89 90 if v.RecipeVersions != nil { 91 ok := object.Key("RecipeVersions") 92 if err := awsRestjson1_serializeDocumentRecipeVersionList(v.RecipeVersions, ok); err != nil { 93 return err 94 } 95 } 96 97 return nil 98} 99 100type awsRestjson1_serializeOpCreateDataset struct { 101} 102 103func (*awsRestjson1_serializeOpCreateDataset) ID() string { 104 return "OperationSerializer" 105} 106 107func (m *awsRestjson1_serializeOpCreateDataset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 108 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 109) { 110 request, ok := in.Request.(*smithyhttp.Request) 111 if !ok { 112 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 113 } 114 115 input, ok := in.Parameters.(*CreateDatasetInput) 116 _ = input 117 if !ok { 118 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 119 } 120 121 opPath, opQuery := httpbinding.SplitURI("/datasets") 122 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 123 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 124 request.Method = "POST" 125 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 126 if err != nil { 127 return out, metadata, &smithy.SerializationError{Err: err} 128 } 129 130 restEncoder.SetHeader("Content-Type").String("application/json") 131 132 jsonEncoder := smithyjson.NewEncoder() 133 if err := awsRestjson1_serializeOpDocumentCreateDatasetInput(input, jsonEncoder.Value); err != nil { 134 return out, metadata, &smithy.SerializationError{Err: err} 135 } 136 137 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 138 return out, metadata, &smithy.SerializationError{Err: err} 139 } 140 141 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 142 return out, metadata, &smithy.SerializationError{Err: err} 143 } 144 in.Request = request 145 146 return next.HandleSerialize(ctx, in) 147} 148func awsRestjson1_serializeOpHttpBindingsCreateDatasetInput(v *CreateDatasetInput, encoder *httpbinding.Encoder) error { 149 if v == nil { 150 return fmt.Errorf("unsupported serialization of nil %T", v) 151 } 152 153 return nil 154} 155 156func awsRestjson1_serializeOpDocumentCreateDatasetInput(v *CreateDatasetInput, value smithyjson.Value) error { 157 object := value.Object() 158 defer object.Close() 159 160 if len(v.Format) > 0 { 161 ok := object.Key("Format") 162 ok.String(string(v.Format)) 163 } 164 165 if v.FormatOptions != nil { 166 ok := object.Key("FormatOptions") 167 if err := awsRestjson1_serializeDocumentFormatOptions(v.FormatOptions, ok); err != nil { 168 return err 169 } 170 } 171 172 if v.Input != nil { 173 ok := object.Key("Input") 174 if err := awsRestjson1_serializeDocumentInput(v.Input, ok); err != nil { 175 return err 176 } 177 } 178 179 if v.Name != nil { 180 ok := object.Key("Name") 181 ok.String(*v.Name) 182 } 183 184 if v.PathOptions != nil { 185 ok := object.Key("PathOptions") 186 if err := awsRestjson1_serializeDocumentPathOptions(v.PathOptions, ok); err != nil { 187 return err 188 } 189 } 190 191 if v.Tags != nil { 192 ok := object.Key("Tags") 193 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 194 return err 195 } 196 } 197 198 return nil 199} 200 201type awsRestjson1_serializeOpCreateProfileJob struct { 202} 203 204func (*awsRestjson1_serializeOpCreateProfileJob) ID() string { 205 return "OperationSerializer" 206} 207 208func (m *awsRestjson1_serializeOpCreateProfileJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 209 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 210) { 211 request, ok := in.Request.(*smithyhttp.Request) 212 if !ok { 213 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 214 } 215 216 input, ok := in.Parameters.(*CreateProfileJobInput) 217 _ = input 218 if !ok { 219 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 220 } 221 222 opPath, opQuery := httpbinding.SplitURI("/profileJobs") 223 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 224 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 225 request.Method = "POST" 226 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 227 if err != nil { 228 return out, metadata, &smithy.SerializationError{Err: err} 229 } 230 231 restEncoder.SetHeader("Content-Type").String("application/json") 232 233 jsonEncoder := smithyjson.NewEncoder() 234 if err := awsRestjson1_serializeOpDocumentCreateProfileJobInput(input, jsonEncoder.Value); err != nil { 235 return out, metadata, &smithy.SerializationError{Err: err} 236 } 237 238 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 239 return out, metadata, &smithy.SerializationError{Err: err} 240 } 241 242 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 243 return out, metadata, &smithy.SerializationError{Err: err} 244 } 245 in.Request = request 246 247 return next.HandleSerialize(ctx, in) 248} 249func awsRestjson1_serializeOpHttpBindingsCreateProfileJobInput(v *CreateProfileJobInput, encoder *httpbinding.Encoder) error { 250 if v == nil { 251 return fmt.Errorf("unsupported serialization of nil %T", v) 252 } 253 254 return nil 255} 256 257func awsRestjson1_serializeOpDocumentCreateProfileJobInput(v *CreateProfileJobInput, value smithyjson.Value) error { 258 object := value.Object() 259 defer object.Close() 260 261 if v.DatasetName != nil { 262 ok := object.Key("DatasetName") 263 ok.String(*v.DatasetName) 264 } 265 266 if v.EncryptionKeyArn != nil { 267 ok := object.Key("EncryptionKeyArn") 268 ok.String(*v.EncryptionKeyArn) 269 } 270 271 if len(v.EncryptionMode) > 0 { 272 ok := object.Key("EncryptionMode") 273 ok.String(string(v.EncryptionMode)) 274 } 275 276 if v.JobSample != nil { 277 ok := object.Key("JobSample") 278 if err := awsRestjson1_serializeDocumentJobSample(v.JobSample, ok); err != nil { 279 return err 280 } 281 } 282 283 if len(v.LogSubscription) > 0 { 284 ok := object.Key("LogSubscription") 285 ok.String(string(v.LogSubscription)) 286 } 287 288 if v.MaxCapacity != 0 { 289 ok := object.Key("MaxCapacity") 290 ok.Integer(v.MaxCapacity) 291 } 292 293 if v.MaxRetries != 0 { 294 ok := object.Key("MaxRetries") 295 ok.Integer(v.MaxRetries) 296 } 297 298 if v.Name != nil { 299 ok := object.Key("Name") 300 ok.String(*v.Name) 301 } 302 303 if v.OutputLocation != nil { 304 ok := object.Key("OutputLocation") 305 if err := awsRestjson1_serializeDocumentS3Location(v.OutputLocation, ok); err != nil { 306 return err 307 } 308 } 309 310 if v.RoleArn != nil { 311 ok := object.Key("RoleArn") 312 ok.String(*v.RoleArn) 313 } 314 315 if v.Tags != nil { 316 ok := object.Key("Tags") 317 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 318 return err 319 } 320 } 321 322 if v.Timeout != 0 { 323 ok := object.Key("Timeout") 324 ok.Integer(v.Timeout) 325 } 326 327 return nil 328} 329 330type awsRestjson1_serializeOpCreateProject struct { 331} 332 333func (*awsRestjson1_serializeOpCreateProject) ID() string { 334 return "OperationSerializer" 335} 336 337func (m *awsRestjson1_serializeOpCreateProject) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 338 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 339) { 340 request, ok := in.Request.(*smithyhttp.Request) 341 if !ok { 342 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 343 } 344 345 input, ok := in.Parameters.(*CreateProjectInput) 346 _ = input 347 if !ok { 348 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 349 } 350 351 opPath, opQuery := httpbinding.SplitURI("/projects") 352 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 353 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 354 request.Method = "POST" 355 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 356 if err != nil { 357 return out, metadata, &smithy.SerializationError{Err: err} 358 } 359 360 restEncoder.SetHeader("Content-Type").String("application/json") 361 362 jsonEncoder := smithyjson.NewEncoder() 363 if err := awsRestjson1_serializeOpDocumentCreateProjectInput(input, jsonEncoder.Value); err != nil { 364 return out, metadata, &smithy.SerializationError{Err: err} 365 } 366 367 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 368 return out, metadata, &smithy.SerializationError{Err: err} 369 } 370 371 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 372 return out, metadata, &smithy.SerializationError{Err: err} 373 } 374 in.Request = request 375 376 return next.HandleSerialize(ctx, in) 377} 378func awsRestjson1_serializeOpHttpBindingsCreateProjectInput(v *CreateProjectInput, encoder *httpbinding.Encoder) error { 379 if v == nil { 380 return fmt.Errorf("unsupported serialization of nil %T", v) 381 } 382 383 return nil 384} 385 386func awsRestjson1_serializeOpDocumentCreateProjectInput(v *CreateProjectInput, value smithyjson.Value) error { 387 object := value.Object() 388 defer object.Close() 389 390 if v.DatasetName != nil { 391 ok := object.Key("DatasetName") 392 ok.String(*v.DatasetName) 393 } 394 395 if v.Name != nil { 396 ok := object.Key("Name") 397 ok.String(*v.Name) 398 } 399 400 if v.RecipeName != nil { 401 ok := object.Key("RecipeName") 402 ok.String(*v.RecipeName) 403 } 404 405 if v.RoleArn != nil { 406 ok := object.Key("RoleArn") 407 ok.String(*v.RoleArn) 408 } 409 410 if v.Sample != nil { 411 ok := object.Key("Sample") 412 if err := awsRestjson1_serializeDocumentSample(v.Sample, ok); err != nil { 413 return err 414 } 415 } 416 417 if v.Tags != nil { 418 ok := object.Key("Tags") 419 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 420 return err 421 } 422 } 423 424 return nil 425} 426 427type awsRestjson1_serializeOpCreateRecipe struct { 428} 429 430func (*awsRestjson1_serializeOpCreateRecipe) ID() string { 431 return "OperationSerializer" 432} 433 434func (m *awsRestjson1_serializeOpCreateRecipe) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 435 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 436) { 437 request, ok := in.Request.(*smithyhttp.Request) 438 if !ok { 439 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 440 } 441 442 input, ok := in.Parameters.(*CreateRecipeInput) 443 _ = input 444 if !ok { 445 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 446 } 447 448 opPath, opQuery := httpbinding.SplitURI("/recipes") 449 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 450 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 451 request.Method = "POST" 452 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 453 if err != nil { 454 return out, metadata, &smithy.SerializationError{Err: err} 455 } 456 457 restEncoder.SetHeader("Content-Type").String("application/json") 458 459 jsonEncoder := smithyjson.NewEncoder() 460 if err := awsRestjson1_serializeOpDocumentCreateRecipeInput(input, jsonEncoder.Value); err != nil { 461 return out, metadata, &smithy.SerializationError{Err: err} 462 } 463 464 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 465 return out, metadata, &smithy.SerializationError{Err: err} 466 } 467 468 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 469 return out, metadata, &smithy.SerializationError{Err: err} 470 } 471 in.Request = request 472 473 return next.HandleSerialize(ctx, in) 474} 475func awsRestjson1_serializeOpHttpBindingsCreateRecipeInput(v *CreateRecipeInput, encoder *httpbinding.Encoder) error { 476 if v == nil { 477 return fmt.Errorf("unsupported serialization of nil %T", v) 478 } 479 480 return nil 481} 482 483func awsRestjson1_serializeOpDocumentCreateRecipeInput(v *CreateRecipeInput, value smithyjson.Value) error { 484 object := value.Object() 485 defer object.Close() 486 487 if v.Description != nil { 488 ok := object.Key("Description") 489 ok.String(*v.Description) 490 } 491 492 if v.Name != nil { 493 ok := object.Key("Name") 494 ok.String(*v.Name) 495 } 496 497 if v.Steps != nil { 498 ok := object.Key("Steps") 499 if err := awsRestjson1_serializeDocumentRecipeStepList(v.Steps, ok); err != nil { 500 return err 501 } 502 } 503 504 if v.Tags != nil { 505 ok := object.Key("Tags") 506 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 507 return err 508 } 509 } 510 511 return nil 512} 513 514type awsRestjson1_serializeOpCreateRecipeJob struct { 515} 516 517func (*awsRestjson1_serializeOpCreateRecipeJob) ID() string { 518 return "OperationSerializer" 519} 520 521func (m *awsRestjson1_serializeOpCreateRecipeJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 522 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 523) { 524 request, ok := in.Request.(*smithyhttp.Request) 525 if !ok { 526 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 527 } 528 529 input, ok := in.Parameters.(*CreateRecipeJobInput) 530 _ = input 531 if !ok { 532 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 533 } 534 535 opPath, opQuery := httpbinding.SplitURI("/recipeJobs") 536 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 537 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 538 request.Method = "POST" 539 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 540 if err != nil { 541 return out, metadata, &smithy.SerializationError{Err: err} 542 } 543 544 restEncoder.SetHeader("Content-Type").String("application/json") 545 546 jsonEncoder := smithyjson.NewEncoder() 547 if err := awsRestjson1_serializeOpDocumentCreateRecipeJobInput(input, jsonEncoder.Value); err != nil { 548 return out, metadata, &smithy.SerializationError{Err: err} 549 } 550 551 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 552 return out, metadata, &smithy.SerializationError{Err: err} 553 } 554 555 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 556 return out, metadata, &smithy.SerializationError{Err: err} 557 } 558 in.Request = request 559 560 return next.HandleSerialize(ctx, in) 561} 562func awsRestjson1_serializeOpHttpBindingsCreateRecipeJobInput(v *CreateRecipeJobInput, encoder *httpbinding.Encoder) error { 563 if v == nil { 564 return fmt.Errorf("unsupported serialization of nil %T", v) 565 } 566 567 return nil 568} 569 570func awsRestjson1_serializeOpDocumentCreateRecipeJobInput(v *CreateRecipeJobInput, value smithyjson.Value) error { 571 object := value.Object() 572 defer object.Close() 573 574 if v.DatasetName != nil { 575 ok := object.Key("DatasetName") 576 ok.String(*v.DatasetName) 577 } 578 579 if v.EncryptionKeyArn != nil { 580 ok := object.Key("EncryptionKeyArn") 581 ok.String(*v.EncryptionKeyArn) 582 } 583 584 if len(v.EncryptionMode) > 0 { 585 ok := object.Key("EncryptionMode") 586 ok.String(string(v.EncryptionMode)) 587 } 588 589 if len(v.LogSubscription) > 0 { 590 ok := object.Key("LogSubscription") 591 ok.String(string(v.LogSubscription)) 592 } 593 594 if v.MaxCapacity != 0 { 595 ok := object.Key("MaxCapacity") 596 ok.Integer(v.MaxCapacity) 597 } 598 599 if v.MaxRetries != 0 { 600 ok := object.Key("MaxRetries") 601 ok.Integer(v.MaxRetries) 602 } 603 604 if v.Name != nil { 605 ok := object.Key("Name") 606 ok.String(*v.Name) 607 } 608 609 if v.Outputs != nil { 610 ok := object.Key("Outputs") 611 if err := awsRestjson1_serializeDocumentOutputList(v.Outputs, ok); err != nil { 612 return err 613 } 614 } 615 616 if v.ProjectName != nil { 617 ok := object.Key("ProjectName") 618 ok.String(*v.ProjectName) 619 } 620 621 if v.RecipeReference != nil { 622 ok := object.Key("RecipeReference") 623 if err := awsRestjson1_serializeDocumentRecipeReference(v.RecipeReference, ok); err != nil { 624 return err 625 } 626 } 627 628 if v.RoleArn != nil { 629 ok := object.Key("RoleArn") 630 ok.String(*v.RoleArn) 631 } 632 633 if v.Tags != nil { 634 ok := object.Key("Tags") 635 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 636 return err 637 } 638 } 639 640 if v.Timeout != 0 { 641 ok := object.Key("Timeout") 642 ok.Integer(v.Timeout) 643 } 644 645 return nil 646} 647 648type awsRestjson1_serializeOpCreateSchedule struct { 649} 650 651func (*awsRestjson1_serializeOpCreateSchedule) ID() string { 652 return "OperationSerializer" 653} 654 655func (m *awsRestjson1_serializeOpCreateSchedule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 656 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 657) { 658 request, ok := in.Request.(*smithyhttp.Request) 659 if !ok { 660 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 661 } 662 663 input, ok := in.Parameters.(*CreateScheduleInput) 664 _ = input 665 if !ok { 666 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 667 } 668 669 opPath, opQuery := httpbinding.SplitURI("/schedules") 670 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 671 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 672 request.Method = "POST" 673 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 674 if err != nil { 675 return out, metadata, &smithy.SerializationError{Err: err} 676 } 677 678 restEncoder.SetHeader("Content-Type").String("application/json") 679 680 jsonEncoder := smithyjson.NewEncoder() 681 if err := awsRestjson1_serializeOpDocumentCreateScheduleInput(input, jsonEncoder.Value); err != nil { 682 return out, metadata, &smithy.SerializationError{Err: err} 683 } 684 685 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 686 return out, metadata, &smithy.SerializationError{Err: err} 687 } 688 689 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 690 return out, metadata, &smithy.SerializationError{Err: err} 691 } 692 in.Request = request 693 694 return next.HandleSerialize(ctx, in) 695} 696func awsRestjson1_serializeOpHttpBindingsCreateScheduleInput(v *CreateScheduleInput, encoder *httpbinding.Encoder) error { 697 if v == nil { 698 return fmt.Errorf("unsupported serialization of nil %T", v) 699 } 700 701 return nil 702} 703 704func awsRestjson1_serializeOpDocumentCreateScheduleInput(v *CreateScheduleInput, value smithyjson.Value) error { 705 object := value.Object() 706 defer object.Close() 707 708 if v.CronExpression != nil { 709 ok := object.Key("CronExpression") 710 ok.String(*v.CronExpression) 711 } 712 713 if v.JobNames != nil { 714 ok := object.Key("JobNames") 715 if err := awsRestjson1_serializeDocumentJobNameList(v.JobNames, ok); err != nil { 716 return err 717 } 718 } 719 720 if v.Name != nil { 721 ok := object.Key("Name") 722 ok.String(*v.Name) 723 } 724 725 if v.Tags != nil { 726 ok := object.Key("Tags") 727 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 728 return err 729 } 730 } 731 732 return nil 733} 734 735type awsRestjson1_serializeOpDeleteDataset struct { 736} 737 738func (*awsRestjson1_serializeOpDeleteDataset) ID() string { 739 return "OperationSerializer" 740} 741 742func (m *awsRestjson1_serializeOpDeleteDataset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 743 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 744) { 745 request, ok := in.Request.(*smithyhttp.Request) 746 if !ok { 747 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 748 } 749 750 input, ok := in.Parameters.(*DeleteDatasetInput) 751 _ = input 752 if !ok { 753 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 754 } 755 756 opPath, opQuery := httpbinding.SplitURI("/datasets/{Name}") 757 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 758 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 759 request.Method = "DELETE" 760 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 761 if err != nil { 762 return out, metadata, &smithy.SerializationError{Err: err} 763 } 764 765 if err := awsRestjson1_serializeOpHttpBindingsDeleteDatasetInput(input, restEncoder); err != nil { 766 return out, metadata, &smithy.SerializationError{Err: err} 767 } 768 769 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 770 return out, metadata, &smithy.SerializationError{Err: err} 771 } 772 in.Request = request 773 774 return next.HandleSerialize(ctx, in) 775} 776func awsRestjson1_serializeOpHttpBindingsDeleteDatasetInput(v *DeleteDatasetInput, encoder *httpbinding.Encoder) error { 777 if v == nil { 778 return fmt.Errorf("unsupported serialization of nil %T", v) 779 } 780 781 if v.Name == nil || len(*v.Name) == 0 { 782 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 783 } 784 if v.Name != nil { 785 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 786 return err 787 } 788 } 789 790 return nil 791} 792 793type awsRestjson1_serializeOpDeleteJob struct { 794} 795 796func (*awsRestjson1_serializeOpDeleteJob) ID() string { 797 return "OperationSerializer" 798} 799 800func (m *awsRestjson1_serializeOpDeleteJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 801 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 802) { 803 request, ok := in.Request.(*smithyhttp.Request) 804 if !ok { 805 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 806 } 807 808 input, ok := in.Parameters.(*DeleteJobInput) 809 _ = input 810 if !ok { 811 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 812 } 813 814 opPath, opQuery := httpbinding.SplitURI("/jobs/{Name}") 815 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 816 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 817 request.Method = "DELETE" 818 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 819 if err != nil { 820 return out, metadata, &smithy.SerializationError{Err: err} 821 } 822 823 if err := awsRestjson1_serializeOpHttpBindingsDeleteJobInput(input, restEncoder); err != nil { 824 return out, metadata, &smithy.SerializationError{Err: err} 825 } 826 827 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 828 return out, metadata, &smithy.SerializationError{Err: err} 829 } 830 in.Request = request 831 832 return next.HandleSerialize(ctx, in) 833} 834func awsRestjson1_serializeOpHttpBindingsDeleteJobInput(v *DeleteJobInput, encoder *httpbinding.Encoder) error { 835 if v == nil { 836 return fmt.Errorf("unsupported serialization of nil %T", v) 837 } 838 839 if v.Name == nil || len(*v.Name) == 0 { 840 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 841 } 842 if v.Name != nil { 843 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 844 return err 845 } 846 } 847 848 return nil 849} 850 851type awsRestjson1_serializeOpDeleteProject struct { 852} 853 854func (*awsRestjson1_serializeOpDeleteProject) ID() string { 855 return "OperationSerializer" 856} 857 858func (m *awsRestjson1_serializeOpDeleteProject) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 859 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 860) { 861 request, ok := in.Request.(*smithyhttp.Request) 862 if !ok { 863 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 864 } 865 866 input, ok := in.Parameters.(*DeleteProjectInput) 867 _ = input 868 if !ok { 869 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 870 } 871 872 opPath, opQuery := httpbinding.SplitURI("/projects/{Name}") 873 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 874 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 875 request.Method = "DELETE" 876 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 877 if err != nil { 878 return out, metadata, &smithy.SerializationError{Err: err} 879 } 880 881 if err := awsRestjson1_serializeOpHttpBindingsDeleteProjectInput(input, restEncoder); err != nil { 882 return out, metadata, &smithy.SerializationError{Err: err} 883 } 884 885 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 886 return out, metadata, &smithy.SerializationError{Err: err} 887 } 888 in.Request = request 889 890 return next.HandleSerialize(ctx, in) 891} 892func awsRestjson1_serializeOpHttpBindingsDeleteProjectInput(v *DeleteProjectInput, encoder *httpbinding.Encoder) error { 893 if v == nil { 894 return fmt.Errorf("unsupported serialization of nil %T", v) 895 } 896 897 if v.Name == nil || len(*v.Name) == 0 { 898 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 899 } 900 if v.Name != nil { 901 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 902 return err 903 } 904 } 905 906 return nil 907} 908 909type awsRestjson1_serializeOpDeleteRecipeVersion struct { 910} 911 912func (*awsRestjson1_serializeOpDeleteRecipeVersion) ID() string { 913 return "OperationSerializer" 914} 915 916func (m *awsRestjson1_serializeOpDeleteRecipeVersion) 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.(*DeleteRecipeVersionInput) 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("/recipes/{Name}/recipeVersion/{RecipeVersion}") 931 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 932 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 933 request.Method = "DELETE" 934 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 935 if err != nil { 936 return out, metadata, &smithy.SerializationError{Err: err} 937 } 938 939 if err := awsRestjson1_serializeOpHttpBindingsDeleteRecipeVersionInput(input, restEncoder); err != nil { 940 return out, metadata, &smithy.SerializationError{Err: err} 941 } 942 943 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 944 return out, metadata, &smithy.SerializationError{Err: err} 945 } 946 in.Request = request 947 948 return next.HandleSerialize(ctx, in) 949} 950func awsRestjson1_serializeOpHttpBindingsDeleteRecipeVersionInput(v *DeleteRecipeVersionInput, encoder *httpbinding.Encoder) error { 951 if v == nil { 952 return fmt.Errorf("unsupported serialization of nil %T", v) 953 } 954 955 if v.Name == nil || len(*v.Name) == 0 { 956 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 957 } 958 if v.Name != nil { 959 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 960 return err 961 } 962 } 963 964 if v.RecipeVersion == nil || len(*v.RecipeVersion) == 0 { 965 return &smithy.SerializationError{Err: fmt.Errorf("input member RecipeVersion must not be empty")} 966 } 967 if v.RecipeVersion != nil { 968 if err := encoder.SetURI("RecipeVersion").String(*v.RecipeVersion); err != nil { 969 return err 970 } 971 } 972 973 return nil 974} 975 976type awsRestjson1_serializeOpDeleteSchedule struct { 977} 978 979func (*awsRestjson1_serializeOpDeleteSchedule) ID() string { 980 return "OperationSerializer" 981} 982 983func (m *awsRestjson1_serializeOpDeleteSchedule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 984 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 985) { 986 request, ok := in.Request.(*smithyhttp.Request) 987 if !ok { 988 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 989 } 990 991 input, ok := in.Parameters.(*DeleteScheduleInput) 992 _ = input 993 if !ok { 994 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 995 } 996 997 opPath, opQuery := httpbinding.SplitURI("/schedules/{Name}") 998 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 999 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1000 request.Method = "DELETE" 1001 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1002 if err != nil { 1003 return out, metadata, &smithy.SerializationError{Err: err} 1004 } 1005 1006 if err := awsRestjson1_serializeOpHttpBindingsDeleteScheduleInput(input, restEncoder); err != nil { 1007 return out, metadata, &smithy.SerializationError{Err: err} 1008 } 1009 1010 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1011 return out, metadata, &smithy.SerializationError{Err: err} 1012 } 1013 in.Request = request 1014 1015 return next.HandleSerialize(ctx, in) 1016} 1017func awsRestjson1_serializeOpHttpBindingsDeleteScheduleInput(v *DeleteScheduleInput, encoder *httpbinding.Encoder) error { 1018 if v == nil { 1019 return fmt.Errorf("unsupported serialization of nil %T", v) 1020 } 1021 1022 if v.Name == nil || len(*v.Name) == 0 { 1023 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 1024 } 1025 if v.Name != nil { 1026 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 1027 return err 1028 } 1029 } 1030 1031 return nil 1032} 1033 1034type awsRestjson1_serializeOpDescribeDataset struct { 1035} 1036 1037func (*awsRestjson1_serializeOpDescribeDataset) ID() string { 1038 return "OperationSerializer" 1039} 1040 1041func (m *awsRestjson1_serializeOpDescribeDataset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1042 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1043) { 1044 request, ok := in.Request.(*smithyhttp.Request) 1045 if !ok { 1046 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1047 } 1048 1049 input, ok := in.Parameters.(*DescribeDatasetInput) 1050 _ = input 1051 if !ok { 1052 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1053 } 1054 1055 opPath, opQuery := httpbinding.SplitURI("/datasets/{Name}") 1056 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1057 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1058 request.Method = "GET" 1059 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1060 if err != nil { 1061 return out, metadata, &smithy.SerializationError{Err: err} 1062 } 1063 1064 if err := awsRestjson1_serializeOpHttpBindingsDescribeDatasetInput(input, restEncoder); err != nil { 1065 return out, metadata, &smithy.SerializationError{Err: err} 1066 } 1067 1068 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1069 return out, metadata, &smithy.SerializationError{Err: err} 1070 } 1071 in.Request = request 1072 1073 return next.HandleSerialize(ctx, in) 1074} 1075func awsRestjson1_serializeOpHttpBindingsDescribeDatasetInput(v *DescribeDatasetInput, encoder *httpbinding.Encoder) error { 1076 if v == nil { 1077 return fmt.Errorf("unsupported serialization of nil %T", v) 1078 } 1079 1080 if v.Name == nil || len(*v.Name) == 0 { 1081 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 1082 } 1083 if v.Name != nil { 1084 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 1085 return err 1086 } 1087 } 1088 1089 return nil 1090} 1091 1092type awsRestjson1_serializeOpDescribeJob struct { 1093} 1094 1095func (*awsRestjson1_serializeOpDescribeJob) ID() string { 1096 return "OperationSerializer" 1097} 1098 1099func (m *awsRestjson1_serializeOpDescribeJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1100 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1101) { 1102 request, ok := in.Request.(*smithyhttp.Request) 1103 if !ok { 1104 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1105 } 1106 1107 input, ok := in.Parameters.(*DescribeJobInput) 1108 _ = input 1109 if !ok { 1110 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1111 } 1112 1113 opPath, opQuery := httpbinding.SplitURI("/jobs/{Name}") 1114 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1115 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1116 request.Method = "GET" 1117 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1118 if err != nil { 1119 return out, metadata, &smithy.SerializationError{Err: err} 1120 } 1121 1122 if err := awsRestjson1_serializeOpHttpBindingsDescribeJobInput(input, restEncoder); err != nil { 1123 return out, metadata, &smithy.SerializationError{Err: err} 1124 } 1125 1126 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1127 return out, metadata, &smithy.SerializationError{Err: err} 1128 } 1129 in.Request = request 1130 1131 return next.HandleSerialize(ctx, in) 1132} 1133func awsRestjson1_serializeOpHttpBindingsDescribeJobInput(v *DescribeJobInput, encoder *httpbinding.Encoder) error { 1134 if v == nil { 1135 return fmt.Errorf("unsupported serialization of nil %T", v) 1136 } 1137 1138 if v.Name == nil || len(*v.Name) == 0 { 1139 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 1140 } 1141 if v.Name != nil { 1142 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 1143 return err 1144 } 1145 } 1146 1147 return nil 1148} 1149 1150type awsRestjson1_serializeOpDescribeJobRun struct { 1151} 1152 1153func (*awsRestjson1_serializeOpDescribeJobRun) ID() string { 1154 return "OperationSerializer" 1155} 1156 1157func (m *awsRestjson1_serializeOpDescribeJobRun) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1158 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1159) { 1160 request, ok := in.Request.(*smithyhttp.Request) 1161 if !ok { 1162 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1163 } 1164 1165 input, ok := in.Parameters.(*DescribeJobRunInput) 1166 _ = input 1167 if !ok { 1168 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1169 } 1170 1171 opPath, opQuery := httpbinding.SplitURI("/jobs/{Name}/jobRun/{RunId}") 1172 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1173 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1174 request.Method = "GET" 1175 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1176 if err != nil { 1177 return out, metadata, &smithy.SerializationError{Err: err} 1178 } 1179 1180 if err := awsRestjson1_serializeOpHttpBindingsDescribeJobRunInput(input, restEncoder); err != nil { 1181 return out, metadata, &smithy.SerializationError{Err: err} 1182 } 1183 1184 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1185 return out, metadata, &smithy.SerializationError{Err: err} 1186 } 1187 in.Request = request 1188 1189 return next.HandleSerialize(ctx, in) 1190} 1191func awsRestjson1_serializeOpHttpBindingsDescribeJobRunInput(v *DescribeJobRunInput, encoder *httpbinding.Encoder) error { 1192 if v == nil { 1193 return fmt.Errorf("unsupported serialization of nil %T", v) 1194 } 1195 1196 if v.Name == nil || len(*v.Name) == 0 { 1197 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 1198 } 1199 if v.Name != nil { 1200 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 1201 return err 1202 } 1203 } 1204 1205 if v.RunId == nil || len(*v.RunId) == 0 { 1206 return &smithy.SerializationError{Err: fmt.Errorf("input member RunId must not be empty")} 1207 } 1208 if v.RunId != nil { 1209 if err := encoder.SetURI("RunId").String(*v.RunId); err != nil { 1210 return err 1211 } 1212 } 1213 1214 return nil 1215} 1216 1217type awsRestjson1_serializeOpDescribeProject struct { 1218} 1219 1220func (*awsRestjson1_serializeOpDescribeProject) ID() string { 1221 return "OperationSerializer" 1222} 1223 1224func (m *awsRestjson1_serializeOpDescribeProject) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1225 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1226) { 1227 request, ok := in.Request.(*smithyhttp.Request) 1228 if !ok { 1229 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1230 } 1231 1232 input, ok := in.Parameters.(*DescribeProjectInput) 1233 _ = input 1234 if !ok { 1235 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1236 } 1237 1238 opPath, opQuery := httpbinding.SplitURI("/projects/{Name}") 1239 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1240 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1241 request.Method = "GET" 1242 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1243 if err != nil { 1244 return out, metadata, &smithy.SerializationError{Err: err} 1245 } 1246 1247 if err := awsRestjson1_serializeOpHttpBindingsDescribeProjectInput(input, restEncoder); err != nil { 1248 return out, metadata, &smithy.SerializationError{Err: err} 1249 } 1250 1251 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1252 return out, metadata, &smithy.SerializationError{Err: err} 1253 } 1254 in.Request = request 1255 1256 return next.HandleSerialize(ctx, in) 1257} 1258func awsRestjson1_serializeOpHttpBindingsDescribeProjectInput(v *DescribeProjectInput, encoder *httpbinding.Encoder) error { 1259 if v == nil { 1260 return fmt.Errorf("unsupported serialization of nil %T", v) 1261 } 1262 1263 if v.Name == nil || len(*v.Name) == 0 { 1264 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 1265 } 1266 if v.Name != nil { 1267 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 1268 return err 1269 } 1270 } 1271 1272 return nil 1273} 1274 1275type awsRestjson1_serializeOpDescribeRecipe struct { 1276} 1277 1278func (*awsRestjson1_serializeOpDescribeRecipe) ID() string { 1279 return "OperationSerializer" 1280} 1281 1282func (m *awsRestjson1_serializeOpDescribeRecipe) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1283 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1284) { 1285 request, ok := in.Request.(*smithyhttp.Request) 1286 if !ok { 1287 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1288 } 1289 1290 input, ok := in.Parameters.(*DescribeRecipeInput) 1291 _ = input 1292 if !ok { 1293 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1294 } 1295 1296 opPath, opQuery := httpbinding.SplitURI("/recipes/{Name}") 1297 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1298 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1299 request.Method = "GET" 1300 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1301 if err != nil { 1302 return out, metadata, &smithy.SerializationError{Err: err} 1303 } 1304 1305 if err := awsRestjson1_serializeOpHttpBindingsDescribeRecipeInput(input, restEncoder); err != nil { 1306 return out, metadata, &smithy.SerializationError{Err: err} 1307 } 1308 1309 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1310 return out, metadata, &smithy.SerializationError{Err: err} 1311 } 1312 in.Request = request 1313 1314 return next.HandleSerialize(ctx, in) 1315} 1316func awsRestjson1_serializeOpHttpBindingsDescribeRecipeInput(v *DescribeRecipeInput, encoder *httpbinding.Encoder) error { 1317 if v == nil { 1318 return fmt.Errorf("unsupported serialization of nil %T", v) 1319 } 1320 1321 if v.Name == nil || len(*v.Name) == 0 { 1322 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 1323 } 1324 if v.Name != nil { 1325 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 1326 return err 1327 } 1328 } 1329 1330 if v.RecipeVersion != nil { 1331 encoder.SetQuery("recipeVersion").String(*v.RecipeVersion) 1332 } 1333 1334 return nil 1335} 1336 1337type awsRestjson1_serializeOpDescribeSchedule struct { 1338} 1339 1340func (*awsRestjson1_serializeOpDescribeSchedule) ID() string { 1341 return "OperationSerializer" 1342} 1343 1344func (m *awsRestjson1_serializeOpDescribeSchedule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1345 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1346) { 1347 request, ok := in.Request.(*smithyhttp.Request) 1348 if !ok { 1349 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1350 } 1351 1352 input, ok := in.Parameters.(*DescribeScheduleInput) 1353 _ = input 1354 if !ok { 1355 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1356 } 1357 1358 opPath, opQuery := httpbinding.SplitURI("/schedules/{Name}") 1359 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1360 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1361 request.Method = "GET" 1362 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1363 if err != nil { 1364 return out, metadata, &smithy.SerializationError{Err: err} 1365 } 1366 1367 if err := awsRestjson1_serializeOpHttpBindingsDescribeScheduleInput(input, restEncoder); err != nil { 1368 return out, metadata, &smithy.SerializationError{Err: err} 1369 } 1370 1371 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1372 return out, metadata, &smithy.SerializationError{Err: err} 1373 } 1374 in.Request = request 1375 1376 return next.HandleSerialize(ctx, in) 1377} 1378func awsRestjson1_serializeOpHttpBindingsDescribeScheduleInput(v *DescribeScheduleInput, encoder *httpbinding.Encoder) error { 1379 if v == nil { 1380 return fmt.Errorf("unsupported serialization of nil %T", v) 1381 } 1382 1383 if v.Name == nil || len(*v.Name) == 0 { 1384 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 1385 } 1386 if v.Name != nil { 1387 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 1388 return err 1389 } 1390 } 1391 1392 return nil 1393} 1394 1395type awsRestjson1_serializeOpListDatasets struct { 1396} 1397 1398func (*awsRestjson1_serializeOpListDatasets) ID() string { 1399 return "OperationSerializer" 1400} 1401 1402func (m *awsRestjson1_serializeOpListDatasets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1403 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1404) { 1405 request, ok := in.Request.(*smithyhttp.Request) 1406 if !ok { 1407 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1408 } 1409 1410 input, ok := in.Parameters.(*ListDatasetsInput) 1411 _ = input 1412 if !ok { 1413 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1414 } 1415 1416 opPath, opQuery := httpbinding.SplitURI("/datasets") 1417 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1418 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1419 request.Method = "GET" 1420 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1421 if err != nil { 1422 return out, metadata, &smithy.SerializationError{Err: err} 1423 } 1424 1425 if err := awsRestjson1_serializeOpHttpBindingsListDatasetsInput(input, restEncoder); err != nil { 1426 return out, metadata, &smithy.SerializationError{Err: err} 1427 } 1428 1429 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1430 return out, metadata, &smithy.SerializationError{Err: err} 1431 } 1432 in.Request = request 1433 1434 return next.HandleSerialize(ctx, in) 1435} 1436func awsRestjson1_serializeOpHttpBindingsListDatasetsInput(v *ListDatasetsInput, encoder *httpbinding.Encoder) error { 1437 if v == nil { 1438 return fmt.Errorf("unsupported serialization of nil %T", v) 1439 } 1440 1441 if v.MaxResults != nil { 1442 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1443 } 1444 1445 if v.NextToken != nil { 1446 encoder.SetQuery("nextToken").String(*v.NextToken) 1447 } 1448 1449 return nil 1450} 1451 1452type awsRestjson1_serializeOpListJobRuns struct { 1453} 1454 1455func (*awsRestjson1_serializeOpListJobRuns) ID() string { 1456 return "OperationSerializer" 1457} 1458 1459func (m *awsRestjson1_serializeOpListJobRuns) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1460 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1461) { 1462 request, ok := in.Request.(*smithyhttp.Request) 1463 if !ok { 1464 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1465 } 1466 1467 input, ok := in.Parameters.(*ListJobRunsInput) 1468 _ = input 1469 if !ok { 1470 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1471 } 1472 1473 opPath, opQuery := httpbinding.SplitURI("/jobs/{Name}/jobRuns") 1474 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1475 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1476 request.Method = "GET" 1477 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1478 if err != nil { 1479 return out, metadata, &smithy.SerializationError{Err: err} 1480 } 1481 1482 if err := awsRestjson1_serializeOpHttpBindingsListJobRunsInput(input, restEncoder); err != nil { 1483 return out, metadata, &smithy.SerializationError{Err: err} 1484 } 1485 1486 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1487 return out, metadata, &smithy.SerializationError{Err: err} 1488 } 1489 in.Request = request 1490 1491 return next.HandleSerialize(ctx, in) 1492} 1493func awsRestjson1_serializeOpHttpBindingsListJobRunsInput(v *ListJobRunsInput, encoder *httpbinding.Encoder) error { 1494 if v == nil { 1495 return fmt.Errorf("unsupported serialization of nil %T", v) 1496 } 1497 1498 if v.MaxResults != nil { 1499 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1500 } 1501 1502 if v.Name == nil || len(*v.Name) == 0 { 1503 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 1504 } 1505 if v.Name != nil { 1506 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 1507 return err 1508 } 1509 } 1510 1511 if v.NextToken != nil { 1512 encoder.SetQuery("nextToken").String(*v.NextToken) 1513 } 1514 1515 return nil 1516} 1517 1518type awsRestjson1_serializeOpListJobs struct { 1519} 1520 1521func (*awsRestjson1_serializeOpListJobs) ID() string { 1522 return "OperationSerializer" 1523} 1524 1525func (m *awsRestjson1_serializeOpListJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1526 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1527) { 1528 request, ok := in.Request.(*smithyhttp.Request) 1529 if !ok { 1530 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1531 } 1532 1533 input, ok := in.Parameters.(*ListJobsInput) 1534 _ = input 1535 if !ok { 1536 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1537 } 1538 1539 opPath, opQuery := httpbinding.SplitURI("/jobs") 1540 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1541 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1542 request.Method = "GET" 1543 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1544 if err != nil { 1545 return out, metadata, &smithy.SerializationError{Err: err} 1546 } 1547 1548 if err := awsRestjson1_serializeOpHttpBindingsListJobsInput(input, restEncoder); err != nil { 1549 return out, metadata, &smithy.SerializationError{Err: err} 1550 } 1551 1552 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1553 return out, metadata, &smithy.SerializationError{Err: err} 1554 } 1555 in.Request = request 1556 1557 return next.HandleSerialize(ctx, in) 1558} 1559func awsRestjson1_serializeOpHttpBindingsListJobsInput(v *ListJobsInput, encoder *httpbinding.Encoder) error { 1560 if v == nil { 1561 return fmt.Errorf("unsupported serialization of nil %T", v) 1562 } 1563 1564 if v.DatasetName != nil { 1565 encoder.SetQuery("datasetName").String(*v.DatasetName) 1566 } 1567 1568 if v.MaxResults != nil { 1569 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1570 } 1571 1572 if v.NextToken != nil { 1573 encoder.SetQuery("nextToken").String(*v.NextToken) 1574 } 1575 1576 if v.ProjectName != nil { 1577 encoder.SetQuery("projectName").String(*v.ProjectName) 1578 } 1579 1580 return nil 1581} 1582 1583type awsRestjson1_serializeOpListProjects struct { 1584} 1585 1586func (*awsRestjson1_serializeOpListProjects) ID() string { 1587 return "OperationSerializer" 1588} 1589 1590func (m *awsRestjson1_serializeOpListProjects) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1591 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1592) { 1593 request, ok := in.Request.(*smithyhttp.Request) 1594 if !ok { 1595 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1596 } 1597 1598 input, ok := in.Parameters.(*ListProjectsInput) 1599 _ = input 1600 if !ok { 1601 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1602 } 1603 1604 opPath, opQuery := httpbinding.SplitURI("/projects") 1605 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1606 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1607 request.Method = "GET" 1608 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1609 if err != nil { 1610 return out, metadata, &smithy.SerializationError{Err: err} 1611 } 1612 1613 if err := awsRestjson1_serializeOpHttpBindingsListProjectsInput(input, restEncoder); err != nil { 1614 return out, metadata, &smithy.SerializationError{Err: err} 1615 } 1616 1617 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1618 return out, metadata, &smithy.SerializationError{Err: err} 1619 } 1620 in.Request = request 1621 1622 return next.HandleSerialize(ctx, in) 1623} 1624func awsRestjson1_serializeOpHttpBindingsListProjectsInput(v *ListProjectsInput, encoder *httpbinding.Encoder) error { 1625 if v == nil { 1626 return fmt.Errorf("unsupported serialization of nil %T", v) 1627 } 1628 1629 if v.MaxResults != nil { 1630 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1631 } 1632 1633 if v.NextToken != nil { 1634 encoder.SetQuery("nextToken").String(*v.NextToken) 1635 } 1636 1637 return nil 1638} 1639 1640type awsRestjson1_serializeOpListRecipes struct { 1641} 1642 1643func (*awsRestjson1_serializeOpListRecipes) ID() string { 1644 return "OperationSerializer" 1645} 1646 1647func (m *awsRestjson1_serializeOpListRecipes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1648 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1649) { 1650 request, ok := in.Request.(*smithyhttp.Request) 1651 if !ok { 1652 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1653 } 1654 1655 input, ok := in.Parameters.(*ListRecipesInput) 1656 _ = input 1657 if !ok { 1658 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1659 } 1660 1661 opPath, opQuery := httpbinding.SplitURI("/recipes") 1662 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1663 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1664 request.Method = "GET" 1665 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1666 if err != nil { 1667 return out, metadata, &smithy.SerializationError{Err: err} 1668 } 1669 1670 if err := awsRestjson1_serializeOpHttpBindingsListRecipesInput(input, restEncoder); err != nil { 1671 return out, metadata, &smithy.SerializationError{Err: err} 1672 } 1673 1674 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1675 return out, metadata, &smithy.SerializationError{Err: err} 1676 } 1677 in.Request = request 1678 1679 return next.HandleSerialize(ctx, in) 1680} 1681func awsRestjson1_serializeOpHttpBindingsListRecipesInput(v *ListRecipesInput, encoder *httpbinding.Encoder) error { 1682 if v == nil { 1683 return fmt.Errorf("unsupported serialization of nil %T", v) 1684 } 1685 1686 if v.MaxResults != nil { 1687 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1688 } 1689 1690 if v.NextToken != nil { 1691 encoder.SetQuery("nextToken").String(*v.NextToken) 1692 } 1693 1694 if v.RecipeVersion != nil { 1695 encoder.SetQuery("recipeVersion").String(*v.RecipeVersion) 1696 } 1697 1698 return nil 1699} 1700 1701type awsRestjson1_serializeOpListRecipeVersions struct { 1702} 1703 1704func (*awsRestjson1_serializeOpListRecipeVersions) ID() string { 1705 return "OperationSerializer" 1706} 1707 1708func (m *awsRestjson1_serializeOpListRecipeVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1709 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1710) { 1711 request, ok := in.Request.(*smithyhttp.Request) 1712 if !ok { 1713 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1714 } 1715 1716 input, ok := in.Parameters.(*ListRecipeVersionsInput) 1717 _ = input 1718 if !ok { 1719 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1720 } 1721 1722 opPath, opQuery := httpbinding.SplitURI("/recipeVersions") 1723 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1724 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1725 request.Method = "GET" 1726 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1727 if err != nil { 1728 return out, metadata, &smithy.SerializationError{Err: err} 1729 } 1730 1731 if err := awsRestjson1_serializeOpHttpBindingsListRecipeVersionsInput(input, restEncoder); err != nil { 1732 return out, metadata, &smithy.SerializationError{Err: err} 1733 } 1734 1735 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1736 return out, metadata, &smithy.SerializationError{Err: err} 1737 } 1738 in.Request = request 1739 1740 return next.HandleSerialize(ctx, in) 1741} 1742func awsRestjson1_serializeOpHttpBindingsListRecipeVersionsInput(v *ListRecipeVersionsInput, encoder *httpbinding.Encoder) error { 1743 if v == nil { 1744 return fmt.Errorf("unsupported serialization of nil %T", v) 1745 } 1746 1747 if v.MaxResults != nil { 1748 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1749 } 1750 1751 if v.Name != nil { 1752 encoder.SetQuery("name").String(*v.Name) 1753 } 1754 1755 if v.NextToken != nil { 1756 encoder.SetQuery("nextToken").String(*v.NextToken) 1757 } 1758 1759 return nil 1760} 1761 1762type awsRestjson1_serializeOpListSchedules struct { 1763} 1764 1765func (*awsRestjson1_serializeOpListSchedules) ID() string { 1766 return "OperationSerializer" 1767} 1768 1769func (m *awsRestjson1_serializeOpListSchedules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1770 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1771) { 1772 request, ok := in.Request.(*smithyhttp.Request) 1773 if !ok { 1774 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1775 } 1776 1777 input, ok := in.Parameters.(*ListSchedulesInput) 1778 _ = input 1779 if !ok { 1780 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1781 } 1782 1783 opPath, opQuery := httpbinding.SplitURI("/schedules") 1784 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1785 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1786 request.Method = "GET" 1787 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1788 if err != nil { 1789 return out, metadata, &smithy.SerializationError{Err: err} 1790 } 1791 1792 if err := awsRestjson1_serializeOpHttpBindingsListSchedulesInput(input, restEncoder); err != nil { 1793 return out, metadata, &smithy.SerializationError{Err: err} 1794 } 1795 1796 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1797 return out, metadata, &smithy.SerializationError{Err: err} 1798 } 1799 in.Request = request 1800 1801 return next.HandleSerialize(ctx, in) 1802} 1803func awsRestjson1_serializeOpHttpBindingsListSchedulesInput(v *ListSchedulesInput, encoder *httpbinding.Encoder) error { 1804 if v == nil { 1805 return fmt.Errorf("unsupported serialization of nil %T", v) 1806 } 1807 1808 if v.JobName != nil { 1809 encoder.SetQuery("jobName").String(*v.JobName) 1810 } 1811 1812 if v.MaxResults != nil { 1813 encoder.SetQuery("maxResults").Integer(*v.MaxResults) 1814 } 1815 1816 if v.NextToken != nil { 1817 encoder.SetQuery("nextToken").String(*v.NextToken) 1818 } 1819 1820 return nil 1821} 1822 1823type awsRestjson1_serializeOpListTagsForResource struct { 1824} 1825 1826func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 1827 return "OperationSerializer" 1828} 1829 1830func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1831 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1832) { 1833 request, ok := in.Request.(*smithyhttp.Request) 1834 if !ok { 1835 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1836 } 1837 1838 input, ok := in.Parameters.(*ListTagsForResourceInput) 1839 _ = input 1840 if !ok { 1841 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1842 } 1843 1844 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 1845 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1846 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1847 request.Method = "GET" 1848 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1849 if err != nil { 1850 return out, metadata, &smithy.SerializationError{Err: err} 1851 } 1852 1853 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 1854 return out, metadata, &smithy.SerializationError{Err: err} 1855 } 1856 1857 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1858 return out, metadata, &smithy.SerializationError{Err: err} 1859 } 1860 in.Request = request 1861 1862 return next.HandleSerialize(ctx, in) 1863} 1864func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 1865 if v == nil { 1866 return fmt.Errorf("unsupported serialization of nil %T", v) 1867 } 1868 1869 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1870 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 1871 } 1872 if v.ResourceArn != nil { 1873 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 1874 return err 1875 } 1876 } 1877 1878 return nil 1879} 1880 1881type awsRestjson1_serializeOpPublishRecipe struct { 1882} 1883 1884func (*awsRestjson1_serializeOpPublishRecipe) ID() string { 1885 return "OperationSerializer" 1886} 1887 1888func (m *awsRestjson1_serializeOpPublishRecipe) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1889 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1890) { 1891 request, ok := in.Request.(*smithyhttp.Request) 1892 if !ok { 1893 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1894 } 1895 1896 input, ok := in.Parameters.(*PublishRecipeInput) 1897 _ = input 1898 if !ok { 1899 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1900 } 1901 1902 opPath, opQuery := httpbinding.SplitURI("/recipes/{Name}/publishRecipe") 1903 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1904 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1905 request.Method = "POST" 1906 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1907 if err != nil { 1908 return out, metadata, &smithy.SerializationError{Err: err} 1909 } 1910 1911 if err := awsRestjson1_serializeOpHttpBindingsPublishRecipeInput(input, restEncoder); err != nil { 1912 return out, metadata, &smithy.SerializationError{Err: err} 1913 } 1914 1915 restEncoder.SetHeader("Content-Type").String("application/json") 1916 1917 jsonEncoder := smithyjson.NewEncoder() 1918 if err := awsRestjson1_serializeOpDocumentPublishRecipeInput(input, jsonEncoder.Value); err != nil { 1919 return out, metadata, &smithy.SerializationError{Err: err} 1920 } 1921 1922 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1923 return out, metadata, &smithy.SerializationError{Err: err} 1924 } 1925 1926 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1927 return out, metadata, &smithy.SerializationError{Err: err} 1928 } 1929 in.Request = request 1930 1931 return next.HandleSerialize(ctx, in) 1932} 1933func awsRestjson1_serializeOpHttpBindingsPublishRecipeInput(v *PublishRecipeInput, encoder *httpbinding.Encoder) error { 1934 if v == nil { 1935 return fmt.Errorf("unsupported serialization of nil %T", v) 1936 } 1937 1938 if v.Name == nil || len(*v.Name) == 0 { 1939 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 1940 } 1941 if v.Name != nil { 1942 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 1943 return err 1944 } 1945 } 1946 1947 return nil 1948} 1949 1950func awsRestjson1_serializeOpDocumentPublishRecipeInput(v *PublishRecipeInput, value smithyjson.Value) error { 1951 object := value.Object() 1952 defer object.Close() 1953 1954 if v.Description != nil { 1955 ok := object.Key("Description") 1956 ok.String(*v.Description) 1957 } 1958 1959 return nil 1960} 1961 1962type awsRestjson1_serializeOpSendProjectSessionAction struct { 1963} 1964 1965func (*awsRestjson1_serializeOpSendProjectSessionAction) ID() string { 1966 return "OperationSerializer" 1967} 1968 1969func (m *awsRestjson1_serializeOpSendProjectSessionAction) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1970 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1971) { 1972 request, ok := in.Request.(*smithyhttp.Request) 1973 if !ok { 1974 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1975 } 1976 1977 input, ok := in.Parameters.(*SendProjectSessionActionInput) 1978 _ = input 1979 if !ok { 1980 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1981 } 1982 1983 opPath, opQuery := httpbinding.SplitURI("/projects/{Name}/sendProjectSessionAction") 1984 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 1985 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 1986 request.Method = "PUT" 1987 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1988 if err != nil { 1989 return out, metadata, &smithy.SerializationError{Err: err} 1990 } 1991 1992 if err := awsRestjson1_serializeOpHttpBindingsSendProjectSessionActionInput(input, restEncoder); err != nil { 1993 return out, metadata, &smithy.SerializationError{Err: err} 1994 } 1995 1996 restEncoder.SetHeader("Content-Type").String("application/json") 1997 1998 jsonEncoder := smithyjson.NewEncoder() 1999 if err := awsRestjson1_serializeOpDocumentSendProjectSessionActionInput(input, jsonEncoder.Value); err != nil { 2000 return out, metadata, &smithy.SerializationError{Err: err} 2001 } 2002 2003 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2004 return out, metadata, &smithy.SerializationError{Err: err} 2005 } 2006 2007 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2008 return out, metadata, &smithy.SerializationError{Err: err} 2009 } 2010 in.Request = request 2011 2012 return next.HandleSerialize(ctx, in) 2013} 2014func awsRestjson1_serializeOpHttpBindingsSendProjectSessionActionInput(v *SendProjectSessionActionInput, encoder *httpbinding.Encoder) error { 2015 if v == nil { 2016 return fmt.Errorf("unsupported serialization of nil %T", v) 2017 } 2018 2019 if v.Name == nil || len(*v.Name) == 0 { 2020 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 2021 } 2022 if v.Name != nil { 2023 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 2024 return err 2025 } 2026 } 2027 2028 return nil 2029} 2030 2031func awsRestjson1_serializeOpDocumentSendProjectSessionActionInput(v *SendProjectSessionActionInput, value smithyjson.Value) error { 2032 object := value.Object() 2033 defer object.Close() 2034 2035 if v.ClientSessionId != nil { 2036 ok := object.Key("ClientSessionId") 2037 ok.String(*v.ClientSessionId) 2038 } 2039 2040 if v.Preview { 2041 ok := object.Key("Preview") 2042 ok.Boolean(v.Preview) 2043 } 2044 2045 if v.RecipeStep != nil { 2046 ok := object.Key("RecipeStep") 2047 if err := awsRestjson1_serializeDocumentRecipeStep(v.RecipeStep, ok); err != nil { 2048 return err 2049 } 2050 } 2051 2052 if v.StepIndex != nil { 2053 ok := object.Key("StepIndex") 2054 ok.Integer(*v.StepIndex) 2055 } 2056 2057 if v.ViewFrame != nil { 2058 ok := object.Key("ViewFrame") 2059 if err := awsRestjson1_serializeDocumentViewFrame(v.ViewFrame, ok); err != nil { 2060 return err 2061 } 2062 } 2063 2064 return nil 2065} 2066 2067type awsRestjson1_serializeOpStartJobRun struct { 2068} 2069 2070func (*awsRestjson1_serializeOpStartJobRun) ID() string { 2071 return "OperationSerializer" 2072} 2073 2074func (m *awsRestjson1_serializeOpStartJobRun) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2075 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2076) { 2077 request, ok := in.Request.(*smithyhttp.Request) 2078 if !ok { 2079 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2080 } 2081 2082 input, ok := in.Parameters.(*StartJobRunInput) 2083 _ = input 2084 if !ok { 2085 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2086 } 2087 2088 opPath, opQuery := httpbinding.SplitURI("/jobs/{Name}/startJobRun") 2089 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2090 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2091 request.Method = "POST" 2092 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2093 if err != nil { 2094 return out, metadata, &smithy.SerializationError{Err: err} 2095 } 2096 2097 if err := awsRestjson1_serializeOpHttpBindingsStartJobRunInput(input, restEncoder); err != nil { 2098 return out, metadata, &smithy.SerializationError{Err: err} 2099 } 2100 2101 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2102 return out, metadata, &smithy.SerializationError{Err: err} 2103 } 2104 in.Request = request 2105 2106 return next.HandleSerialize(ctx, in) 2107} 2108func awsRestjson1_serializeOpHttpBindingsStartJobRunInput(v *StartJobRunInput, encoder *httpbinding.Encoder) error { 2109 if v == nil { 2110 return fmt.Errorf("unsupported serialization of nil %T", v) 2111 } 2112 2113 if v.Name == nil || len(*v.Name) == 0 { 2114 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 2115 } 2116 if v.Name != nil { 2117 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 2118 return err 2119 } 2120 } 2121 2122 return nil 2123} 2124 2125type awsRestjson1_serializeOpStartProjectSession struct { 2126} 2127 2128func (*awsRestjson1_serializeOpStartProjectSession) ID() string { 2129 return "OperationSerializer" 2130} 2131 2132func (m *awsRestjson1_serializeOpStartProjectSession) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2133 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2134) { 2135 request, ok := in.Request.(*smithyhttp.Request) 2136 if !ok { 2137 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2138 } 2139 2140 input, ok := in.Parameters.(*StartProjectSessionInput) 2141 _ = input 2142 if !ok { 2143 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2144 } 2145 2146 opPath, opQuery := httpbinding.SplitURI("/projects/{Name}/startProjectSession") 2147 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2148 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2149 request.Method = "PUT" 2150 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2151 if err != nil { 2152 return out, metadata, &smithy.SerializationError{Err: err} 2153 } 2154 2155 if err := awsRestjson1_serializeOpHttpBindingsStartProjectSessionInput(input, restEncoder); err != nil { 2156 return out, metadata, &smithy.SerializationError{Err: err} 2157 } 2158 2159 restEncoder.SetHeader("Content-Type").String("application/json") 2160 2161 jsonEncoder := smithyjson.NewEncoder() 2162 if err := awsRestjson1_serializeOpDocumentStartProjectSessionInput(input, jsonEncoder.Value); err != nil { 2163 return out, metadata, &smithy.SerializationError{Err: err} 2164 } 2165 2166 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2167 return out, metadata, &smithy.SerializationError{Err: err} 2168 } 2169 2170 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2171 return out, metadata, &smithy.SerializationError{Err: err} 2172 } 2173 in.Request = request 2174 2175 return next.HandleSerialize(ctx, in) 2176} 2177func awsRestjson1_serializeOpHttpBindingsStartProjectSessionInput(v *StartProjectSessionInput, encoder *httpbinding.Encoder) error { 2178 if v == nil { 2179 return fmt.Errorf("unsupported serialization of nil %T", v) 2180 } 2181 2182 if v.Name == nil || len(*v.Name) == 0 { 2183 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 2184 } 2185 if v.Name != nil { 2186 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 2187 return err 2188 } 2189 } 2190 2191 return nil 2192} 2193 2194func awsRestjson1_serializeOpDocumentStartProjectSessionInput(v *StartProjectSessionInput, value smithyjson.Value) error { 2195 object := value.Object() 2196 defer object.Close() 2197 2198 if v.AssumeControl { 2199 ok := object.Key("AssumeControl") 2200 ok.Boolean(v.AssumeControl) 2201 } 2202 2203 return nil 2204} 2205 2206type awsRestjson1_serializeOpStopJobRun struct { 2207} 2208 2209func (*awsRestjson1_serializeOpStopJobRun) ID() string { 2210 return "OperationSerializer" 2211} 2212 2213func (m *awsRestjson1_serializeOpStopJobRun) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2214 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2215) { 2216 request, ok := in.Request.(*smithyhttp.Request) 2217 if !ok { 2218 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2219 } 2220 2221 input, ok := in.Parameters.(*StopJobRunInput) 2222 _ = input 2223 if !ok { 2224 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2225 } 2226 2227 opPath, opQuery := httpbinding.SplitURI("/jobs/{Name}/jobRun/{RunId}/stopJobRun") 2228 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2229 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2230 request.Method = "POST" 2231 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2232 if err != nil { 2233 return out, metadata, &smithy.SerializationError{Err: err} 2234 } 2235 2236 if err := awsRestjson1_serializeOpHttpBindingsStopJobRunInput(input, restEncoder); err != nil { 2237 return out, metadata, &smithy.SerializationError{Err: err} 2238 } 2239 2240 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2241 return out, metadata, &smithy.SerializationError{Err: err} 2242 } 2243 in.Request = request 2244 2245 return next.HandleSerialize(ctx, in) 2246} 2247func awsRestjson1_serializeOpHttpBindingsStopJobRunInput(v *StopJobRunInput, encoder *httpbinding.Encoder) error { 2248 if v == nil { 2249 return fmt.Errorf("unsupported serialization of nil %T", v) 2250 } 2251 2252 if v.Name == nil || len(*v.Name) == 0 { 2253 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 2254 } 2255 if v.Name != nil { 2256 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 2257 return err 2258 } 2259 } 2260 2261 if v.RunId == nil || len(*v.RunId) == 0 { 2262 return &smithy.SerializationError{Err: fmt.Errorf("input member RunId must not be empty")} 2263 } 2264 if v.RunId != nil { 2265 if err := encoder.SetURI("RunId").String(*v.RunId); err != nil { 2266 return err 2267 } 2268 } 2269 2270 return nil 2271} 2272 2273type awsRestjson1_serializeOpTagResource struct { 2274} 2275 2276func (*awsRestjson1_serializeOpTagResource) ID() string { 2277 return "OperationSerializer" 2278} 2279 2280func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2281 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2282) { 2283 request, ok := in.Request.(*smithyhttp.Request) 2284 if !ok { 2285 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2286 } 2287 2288 input, ok := in.Parameters.(*TagResourceInput) 2289 _ = input 2290 if !ok { 2291 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2292 } 2293 2294 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 2295 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2296 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2297 request.Method = "POST" 2298 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2299 if err != nil { 2300 return out, metadata, &smithy.SerializationError{Err: err} 2301 } 2302 2303 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 2304 return out, metadata, &smithy.SerializationError{Err: err} 2305 } 2306 2307 restEncoder.SetHeader("Content-Type").String("application/json") 2308 2309 jsonEncoder := smithyjson.NewEncoder() 2310 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 2311 return out, metadata, &smithy.SerializationError{Err: err} 2312 } 2313 2314 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2315 return out, metadata, &smithy.SerializationError{Err: err} 2316 } 2317 2318 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2319 return out, metadata, &smithy.SerializationError{Err: err} 2320 } 2321 in.Request = request 2322 2323 return next.HandleSerialize(ctx, in) 2324} 2325func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 2326 if v == nil { 2327 return fmt.Errorf("unsupported serialization of nil %T", v) 2328 } 2329 2330 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 2331 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 2332 } 2333 if v.ResourceArn != nil { 2334 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 2335 return err 2336 } 2337 } 2338 2339 return nil 2340} 2341 2342func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 2343 object := value.Object() 2344 defer object.Close() 2345 2346 if v.Tags != nil { 2347 ok := object.Key("Tags") 2348 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 2349 return err 2350 } 2351 } 2352 2353 return nil 2354} 2355 2356type awsRestjson1_serializeOpUntagResource struct { 2357} 2358 2359func (*awsRestjson1_serializeOpUntagResource) ID() string { 2360 return "OperationSerializer" 2361} 2362 2363func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2364 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2365) { 2366 request, ok := in.Request.(*smithyhttp.Request) 2367 if !ok { 2368 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2369 } 2370 2371 input, ok := in.Parameters.(*UntagResourceInput) 2372 _ = input 2373 if !ok { 2374 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2375 } 2376 2377 opPath, opQuery := httpbinding.SplitURI("/tags/{ResourceArn}") 2378 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2379 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2380 request.Method = "DELETE" 2381 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2382 if err != nil { 2383 return out, metadata, &smithy.SerializationError{Err: err} 2384 } 2385 2386 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 2387 return out, metadata, &smithy.SerializationError{Err: err} 2388 } 2389 2390 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2391 return out, metadata, &smithy.SerializationError{Err: err} 2392 } 2393 in.Request = request 2394 2395 return next.HandleSerialize(ctx, in) 2396} 2397func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 2398 if v == nil { 2399 return fmt.Errorf("unsupported serialization of nil %T", v) 2400 } 2401 2402 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 2403 return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")} 2404 } 2405 if v.ResourceArn != nil { 2406 if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil { 2407 return err 2408 } 2409 } 2410 2411 if v.TagKeys != nil { 2412 for i := range v.TagKeys { 2413 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 2414 } 2415 } 2416 2417 return nil 2418} 2419 2420type awsRestjson1_serializeOpUpdateDataset struct { 2421} 2422 2423func (*awsRestjson1_serializeOpUpdateDataset) ID() string { 2424 return "OperationSerializer" 2425} 2426 2427func (m *awsRestjson1_serializeOpUpdateDataset) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2428 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2429) { 2430 request, ok := in.Request.(*smithyhttp.Request) 2431 if !ok { 2432 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2433 } 2434 2435 input, ok := in.Parameters.(*UpdateDatasetInput) 2436 _ = input 2437 if !ok { 2438 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2439 } 2440 2441 opPath, opQuery := httpbinding.SplitURI("/datasets/{Name}") 2442 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2443 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2444 request.Method = "PUT" 2445 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2446 if err != nil { 2447 return out, metadata, &smithy.SerializationError{Err: err} 2448 } 2449 2450 if err := awsRestjson1_serializeOpHttpBindingsUpdateDatasetInput(input, restEncoder); err != nil { 2451 return out, metadata, &smithy.SerializationError{Err: err} 2452 } 2453 2454 restEncoder.SetHeader("Content-Type").String("application/json") 2455 2456 jsonEncoder := smithyjson.NewEncoder() 2457 if err := awsRestjson1_serializeOpDocumentUpdateDatasetInput(input, jsonEncoder.Value); err != nil { 2458 return out, metadata, &smithy.SerializationError{Err: err} 2459 } 2460 2461 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2462 return out, metadata, &smithy.SerializationError{Err: err} 2463 } 2464 2465 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2466 return out, metadata, &smithy.SerializationError{Err: err} 2467 } 2468 in.Request = request 2469 2470 return next.HandleSerialize(ctx, in) 2471} 2472func awsRestjson1_serializeOpHttpBindingsUpdateDatasetInput(v *UpdateDatasetInput, encoder *httpbinding.Encoder) error { 2473 if v == nil { 2474 return fmt.Errorf("unsupported serialization of nil %T", v) 2475 } 2476 2477 if v.Name == nil || len(*v.Name) == 0 { 2478 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 2479 } 2480 if v.Name != nil { 2481 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 2482 return err 2483 } 2484 } 2485 2486 return nil 2487} 2488 2489func awsRestjson1_serializeOpDocumentUpdateDatasetInput(v *UpdateDatasetInput, value smithyjson.Value) error { 2490 object := value.Object() 2491 defer object.Close() 2492 2493 if len(v.Format) > 0 { 2494 ok := object.Key("Format") 2495 ok.String(string(v.Format)) 2496 } 2497 2498 if v.FormatOptions != nil { 2499 ok := object.Key("FormatOptions") 2500 if err := awsRestjson1_serializeDocumentFormatOptions(v.FormatOptions, ok); err != nil { 2501 return err 2502 } 2503 } 2504 2505 if v.Input != nil { 2506 ok := object.Key("Input") 2507 if err := awsRestjson1_serializeDocumentInput(v.Input, ok); err != nil { 2508 return err 2509 } 2510 } 2511 2512 if v.PathOptions != nil { 2513 ok := object.Key("PathOptions") 2514 if err := awsRestjson1_serializeDocumentPathOptions(v.PathOptions, ok); err != nil { 2515 return err 2516 } 2517 } 2518 2519 return nil 2520} 2521 2522type awsRestjson1_serializeOpUpdateProfileJob struct { 2523} 2524 2525func (*awsRestjson1_serializeOpUpdateProfileJob) ID() string { 2526 return "OperationSerializer" 2527} 2528 2529func (m *awsRestjson1_serializeOpUpdateProfileJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2530 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2531) { 2532 request, ok := in.Request.(*smithyhttp.Request) 2533 if !ok { 2534 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2535 } 2536 2537 input, ok := in.Parameters.(*UpdateProfileJobInput) 2538 _ = input 2539 if !ok { 2540 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2541 } 2542 2543 opPath, opQuery := httpbinding.SplitURI("/profileJobs/{Name}") 2544 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2545 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2546 request.Method = "PUT" 2547 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2548 if err != nil { 2549 return out, metadata, &smithy.SerializationError{Err: err} 2550 } 2551 2552 if err := awsRestjson1_serializeOpHttpBindingsUpdateProfileJobInput(input, restEncoder); err != nil { 2553 return out, metadata, &smithy.SerializationError{Err: err} 2554 } 2555 2556 restEncoder.SetHeader("Content-Type").String("application/json") 2557 2558 jsonEncoder := smithyjson.NewEncoder() 2559 if err := awsRestjson1_serializeOpDocumentUpdateProfileJobInput(input, jsonEncoder.Value); err != nil { 2560 return out, metadata, &smithy.SerializationError{Err: err} 2561 } 2562 2563 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2564 return out, metadata, &smithy.SerializationError{Err: err} 2565 } 2566 2567 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2568 return out, metadata, &smithy.SerializationError{Err: err} 2569 } 2570 in.Request = request 2571 2572 return next.HandleSerialize(ctx, in) 2573} 2574func awsRestjson1_serializeOpHttpBindingsUpdateProfileJobInput(v *UpdateProfileJobInput, encoder *httpbinding.Encoder) error { 2575 if v == nil { 2576 return fmt.Errorf("unsupported serialization of nil %T", v) 2577 } 2578 2579 if v.Name == nil || len(*v.Name) == 0 { 2580 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 2581 } 2582 if v.Name != nil { 2583 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 2584 return err 2585 } 2586 } 2587 2588 return nil 2589} 2590 2591func awsRestjson1_serializeOpDocumentUpdateProfileJobInput(v *UpdateProfileJobInput, value smithyjson.Value) error { 2592 object := value.Object() 2593 defer object.Close() 2594 2595 if v.EncryptionKeyArn != nil { 2596 ok := object.Key("EncryptionKeyArn") 2597 ok.String(*v.EncryptionKeyArn) 2598 } 2599 2600 if len(v.EncryptionMode) > 0 { 2601 ok := object.Key("EncryptionMode") 2602 ok.String(string(v.EncryptionMode)) 2603 } 2604 2605 if v.JobSample != nil { 2606 ok := object.Key("JobSample") 2607 if err := awsRestjson1_serializeDocumentJobSample(v.JobSample, ok); err != nil { 2608 return err 2609 } 2610 } 2611 2612 if len(v.LogSubscription) > 0 { 2613 ok := object.Key("LogSubscription") 2614 ok.String(string(v.LogSubscription)) 2615 } 2616 2617 if v.MaxCapacity != 0 { 2618 ok := object.Key("MaxCapacity") 2619 ok.Integer(v.MaxCapacity) 2620 } 2621 2622 if v.MaxRetries != 0 { 2623 ok := object.Key("MaxRetries") 2624 ok.Integer(v.MaxRetries) 2625 } 2626 2627 if v.OutputLocation != nil { 2628 ok := object.Key("OutputLocation") 2629 if err := awsRestjson1_serializeDocumentS3Location(v.OutputLocation, ok); err != nil { 2630 return err 2631 } 2632 } 2633 2634 if v.RoleArn != nil { 2635 ok := object.Key("RoleArn") 2636 ok.String(*v.RoleArn) 2637 } 2638 2639 if v.Timeout != 0 { 2640 ok := object.Key("Timeout") 2641 ok.Integer(v.Timeout) 2642 } 2643 2644 return nil 2645} 2646 2647type awsRestjson1_serializeOpUpdateProject struct { 2648} 2649 2650func (*awsRestjson1_serializeOpUpdateProject) ID() string { 2651 return "OperationSerializer" 2652} 2653 2654func (m *awsRestjson1_serializeOpUpdateProject) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2655 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2656) { 2657 request, ok := in.Request.(*smithyhttp.Request) 2658 if !ok { 2659 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2660 } 2661 2662 input, ok := in.Parameters.(*UpdateProjectInput) 2663 _ = input 2664 if !ok { 2665 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2666 } 2667 2668 opPath, opQuery := httpbinding.SplitURI("/projects/{Name}") 2669 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2670 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2671 request.Method = "PUT" 2672 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2673 if err != nil { 2674 return out, metadata, &smithy.SerializationError{Err: err} 2675 } 2676 2677 if err := awsRestjson1_serializeOpHttpBindingsUpdateProjectInput(input, restEncoder); err != nil { 2678 return out, metadata, &smithy.SerializationError{Err: err} 2679 } 2680 2681 restEncoder.SetHeader("Content-Type").String("application/json") 2682 2683 jsonEncoder := smithyjson.NewEncoder() 2684 if err := awsRestjson1_serializeOpDocumentUpdateProjectInput(input, jsonEncoder.Value); err != nil { 2685 return out, metadata, &smithy.SerializationError{Err: err} 2686 } 2687 2688 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2689 return out, metadata, &smithy.SerializationError{Err: err} 2690 } 2691 2692 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2693 return out, metadata, &smithy.SerializationError{Err: err} 2694 } 2695 in.Request = request 2696 2697 return next.HandleSerialize(ctx, in) 2698} 2699func awsRestjson1_serializeOpHttpBindingsUpdateProjectInput(v *UpdateProjectInput, encoder *httpbinding.Encoder) error { 2700 if v == nil { 2701 return fmt.Errorf("unsupported serialization of nil %T", v) 2702 } 2703 2704 if v.Name == nil || len(*v.Name) == 0 { 2705 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 2706 } 2707 if v.Name != nil { 2708 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 2709 return err 2710 } 2711 } 2712 2713 return nil 2714} 2715 2716func awsRestjson1_serializeOpDocumentUpdateProjectInput(v *UpdateProjectInput, value smithyjson.Value) error { 2717 object := value.Object() 2718 defer object.Close() 2719 2720 if v.RoleArn != nil { 2721 ok := object.Key("RoleArn") 2722 ok.String(*v.RoleArn) 2723 } 2724 2725 if v.Sample != nil { 2726 ok := object.Key("Sample") 2727 if err := awsRestjson1_serializeDocumentSample(v.Sample, ok); err != nil { 2728 return err 2729 } 2730 } 2731 2732 return nil 2733} 2734 2735type awsRestjson1_serializeOpUpdateRecipe struct { 2736} 2737 2738func (*awsRestjson1_serializeOpUpdateRecipe) ID() string { 2739 return "OperationSerializer" 2740} 2741 2742func (m *awsRestjson1_serializeOpUpdateRecipe) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2743 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2744) { 2745 request, ok := in.Request.(*smithyhttp.Request) 2746 if !ok { 2747 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2748 } 2749 2750 input, ok := in.Parameters.(*UpdateRecipeInput) 2751 _ = input 2752 if !ok { 2753 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2754 } 2755 2756 opPath, opQuery := httpbinding.SplitURI("/recipes/{Name}") 2757 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2758 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2759 request.Method = "PUT" 2760 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2761 if err != nil { 2762 return out, metadata, &smithy.SerializationError{Err: err} 2763 } 2764 2765 if err := awsRestjson1_serializeOpHttpBindingsUpdateRecipeInput(input, restEncoder); err != nil { 2766 return out, metadata, &smithy.SerializationError{Err: err} 2767 } 2768 2769 restEncoder.SetHeader("Content-Type").String("application/json") 2770 2771 jsonEncoder := smithyjson.NewEncoder() 2772 if err := awsRestjson1_serializeOpDocumentUpdateRecipeInput(input, jsonEncoder.Value); err != nil { 2773 return out, metadata, &smithy.SerializationError{Err: err} 2774 } 2775 2776 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2777 return out, metadata, &smithy.SerializationError{Err: err} 2778 } 2779 2780 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2781 return out, metadata, &smithy.SerializationError{Err: err} 2782 } 2783 in.Request = request 2784 2785 return next.HandleSerialize(ctx, in) 2786} 2787func awsRestjson1_serializeOpHttpBindingsUpdateRecipeInput(v *UpdateRecipeInput, encoder *httpbinding.Encoder) error { 2788 if v == nil { 2789 return fmt.Errorf("unsupported serialization of nil %T", v) 2790 } 2791 2792 if v.Name == nil || len(*v.Name) == 0 { 2793 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 2794 } 2795 if v.Name != nil { 2796 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 2797 return err 2798 } 2799 } 2800 2801 return nil 2802} 2803 2804func awsRestjson1_serializeOpDocumentUpdateRecipeInput(v *UpdateRecipeInput, value smithyjson.Value) error { 2805 object := value.Object() 2806 defer object.Close() 2807 2808 if v.Description != nil { 2809 ok := object.Key("Description") 2810 ok.String(*v.Description) 2811 } 2812 2813 if v.Steps != nil { 2814 ok := object.Key("Steps") 2815 if err := awsRestjson1_serializeDocumentRecipeStepList(v.Steps, ok); err != nil { 2816 return err 2817 } 2818 } 2819 2820 return nil 2821} 2822 2823type awsRestjson1_serializeOpUpdateRecipeJob struct { 2824} 2825 2826func (*awsRestjson1_serializeOpUpdateRecipeJob) ID() string { 2827 return "OperationSerializer" 2828} 2829 2830func (m *awsRestjson1_serializeOpUpdateRecipeJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2831 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2832) { 2833 request, ok := in.Request.(*smithyhttp.Request) 2834 if !ok { 2835 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2836 } 2837 2838 input, ok := in.Parameters.(*UpdateRecipeJobInput) 2839 _ = input 2840 if !ok { 2841 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2842 } 2843 2844 opPath, opQuery := httpbinding.SplitURI("/recipeJobs/{Name}") 2845 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2846 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2847 request.Method = "PUT" 2848 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2849 if err != nil { 2850 return out, metadata, &smithy.SerializationError{Err: err} 2851 } 2852 2853 if err := awsRestjson1_serializeOpHttpBindingsUpdateRecipeJobInput(input, restEncoder); err != nil { 2854 return out, metadata, &smithy.SerializationError{Err: err} 2855 } 2856 2857 restEncoder.SetHeader("Content-Type").String("application/json") 2858 2859 jsonEncoder := smithyjson.NewEncoder() 2860 if err := awsRestjson1_serializeOpDocumentUpdateRecipeJobInput(input, jsonEncoder.Value); err != nil { 2861 return out, metadata, &smithy.SerializationError{Err: err} 2862 } 2863 2864 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2865 return out, metadata, &smithy.SerializationError{Err: err} 2866 } 2867 2868 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2869 return out, metadata, &smithy.SerializationError{Err: err} 2870 } 2871 in.Request = request 2872 2873 return next.HandleSerialize(ctx, in) 2874} 2875func awsRestjson1_serializeOpHttpBindingsUpdateRecipeJobInput(v *UpdateRecipeJobInput, encoder *httpbinding.Encoder) error { 2876 if v == nil { 2877 return fmt.Errorf("unsupported serialization of nil %T", v) 2878 } 2879 2880 if v.Name == nil || len(*v.Name) == 0 { 2881 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 2882 } 2883 if v.Name != nil { 2884 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 2885 return err 2886 } 2887 } 2888 2889 return nil 2890} 2891 2892func awsRestjson1_serializeOpDocumentUpdateRecipeJobInput(v *UpdateRecipeJobInput, value smithyjson.Value) error { 2893 object := value.Object() 2894 defer object.Close() 2895 2896 if v.EncryptionKeyArn != nil { 2897 ok := object.Key("EncryptionKeyArn") 2898 ok.String(*v.EncryptionKeyArn) 2899 } 2900 2901 if len(v.EncryptionMode) > 0 { 2902 ok := object.Key("EncryptionMode") 2903 ok.String(string(v.EncryptionMode)) 2904 } 2905 2906 if len(v.LogSubscription) > 0 { 2907 ok := object.Key("LogSubscription") 2908 ok.String(string(v.LogSubscription)) 2909 } 2910 2911 if v.MaxCapacity != 0 { 2912 ok := object.Key("MaxCapacity") 2913 ok.Integer(v.MaxCapacity) 2914 } 2915 2916 if v.MaxRetries != 0 { 2917 ok := object.Key("MaxRetries") 2918 ok.Integer(v.MaxRetries) 2919 } 2920 2921 if v.Outputs != nil { 2922 ok := object.Key("Outputs") 2923 if err := awsRestjson1_serializeDocumentOutputList(v.Outputs, ok); err != nil { 2924 return err 2925 } 2926 } 2927 2928 if v.RoleArn != nil { 2929 ok := object.Key("RoleArn") 2930 ok.String(*v.RoleArn) 2931 } 2932 2933 if v.Timeout != 0 { 2934 ok := object.Key("Timeout") 2935 ok.Integer(v.Timeout) 2936 } 2937 2938 return nil 2939} 2940 2941type awsRestjson1_serializeOpUpdateSchedule struct { 2942} 2943 2944func (*awsRestjson1_serializeOpUpdateSchedule) ID() string { 2945 return "OperationSerializer" 2946} 2947 2948func (m *awsRestjson1_serializeOpUpdateSchedule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2949 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2950) { 2951 request, ok := in.Request.(*smithyhttp.Request) 2952 if !ok { 2953 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2954 } 2955 2956 input, ok := in.Parameters.(*UpdateScheduleInput) 2957 _ = input 2958 if !ok { 2959 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2960 } 2961 2962 opPath, opQuery := httpbinding.SplitURI("/schedules/{Name}") 2963 request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath) 2964 request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery) 2965 request.Method = "PUT" 2966 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2967 if err != nil { 2968 return out, metadata, &smithy.SerializationError{Err: err} 2969 } 2970 2971 if err := awsRestjson1_serializeOpHttpBindingsUpdateScheduleInput(input, restEncoder); err != nil { 2972 return out, metadata, &smithy.SerializationError{Err: err} 2973 } 2974 2975 restEncoder.SetHeader("Content-Type").String("application/json") 2976 2977 jsonEncoder := smithyjson.NewEncoder() 2978 if err := awsRestjson1_serializeOpDocumentUpdateScheduleInput(input, jsonEncoder.Value); err != nil { 2979 return out, metadata, &smithy.SerializationError{Err: err} 2980 } 2981 2982 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2983 return out, metadata, &smithy.SerializationError{Err: err} 2984 } 2985 2986 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2987 return out, metadata, &smithy.SerializationError{Err: err} 2988 } 2989 in.Request = request 2990 2991 return next.HandleSerialize(ctx, in) 2992} 2993func awsRestjson1_serializeOpHttpBindingsUpdateScheduleInput(v *UpdateScheduleInput, encoder *httpbinding.Encoder) error { 2994 if v == nil { 2995 return fmt.Errorf("unsupported serialization of nil %T", v) 2996 } 2997 2998 if v.Name == nil || len(*v.Name) == 0 { 2999 return &smithy.SerializationError{Err: fmt.Errorf("input member Name must not be empty")} 3000 } 3001 if v.Name != nil { 3002 if err := encoder.SetURI("Name").String(*v.Name); err != nil { 3003 return err 3004 } 3005 } 3006 3007 return nil 3008} 3009 3010func awsRestjson1_serializeOpDocumentUpdateScheduleInput(v *UpdateScheduleInput, value smithyjson.Value) error { 3011 object := value.Object() 3012 defer object.Close() 3013 3014 if v.CronExpression != nil { 3015 ok := object.Key("CronExpression") 3016 ok.String(*v.CronExpression) 3017 } 3018 3019 if v.JobNames != nil { 3020 ok := object.Key("JobNames") 3021 if err := awsRestjson1_serializeDocumentJobNameList(v.JobNames, ok); err != nil { 3022 return err 3023 } 3024 } 3025 3026 return nil 3027} 3028 3029func awsRestjson1_serializeDocumentColumnNameList(v []string, value smithyjson.Value) error { 3030 array := value.Array() 3031 defer array.Close() 3032 3033 for i := range v { 3034 av := array.Value() 3035 av.String(v[i]) 3036 } 3037 return nil 3038} 3039 3040func awsRestjson1_serializeDocumentConditionExpression(v *types.ConditionExpression, value smithyjson.Value) error { 3041 object := value.Object() 3042 defer object.Close() 3043 3044 if v.Condition != nil { 3045 ok := object.Key("Condition") 3046 ok.String(*v.Condition) 3047 } 3048 3049 if v.TargetColumn != nil { 3050 ok := object.Key("TargetColumn") 3051 ok.String(*v.TargetColumn) 3052 } 3053 3054 if v.Value != nil { 3055 ok := object.Key("Value") 3056 ok.String(*v.Value) 3057 } 3058 3059 return nil 3060} 3061 3062func awsRestjson1_serializeDocumentConditionExpressionList(v []types.ConditionExpression, value smithyjson.Value) error { 3063 array := value.Array() 3064 defer array.Close() 3065 3066 for i := range v { 3067 av := array.Value() 3068 if err := awsRestjson1_serializeDocumentConditionExpression(&v[i], av); err != nil { 3069 return err 3070 } 3071 } 3072 return nil 3073} 3074 3075func awsRestjson1_serializeDocumentCsvOptions(v *types.CsvOptions, value smithyjson.Value) error { 3076 object := value.Object() 3077 defer object.Close() 3078 3079 if v.Delimiter != nil { 3080 ok := object.Key("Delimiter") 3081 ok.String(*v.Delimiter) 3082 } 3083 3084 if v.HeaderRow != nil { 3085 ok := object.Key("HeaderRow") 3086 ok.Boolean(*v.HeaderRow) 3087 } 3088 3089 return nil 3090} 3091 3092func awsRestjson1_serializeDocumentCsvOutputOptions(v *types.CsvOutputOptions, value smithyjson.Value) error { 3093 object := value.Object() 3094 defer object.Close() 3095 3096 if v.Delimiter != nil { 3097 ok := object.Key("Delimiter") 3098 ok.String(*v.Delimiter) 3099 } 3100 3101 return nil 3102} 3103 3104func awsRestjson1_serializeDocumentDatabaseInputDefinition(v *types.DatabaseInputDefinition, value smithyjson.Value) error { 3105 object := value.Object() 3106 defer object.Close() 3107 3108 if v.DatabaseTableName != nil { 3109 ok := object.Key("DatabaseTableName") 3110 ok.String(*v.DatabaseTableName) 3111 } 3112 3113 if v.GlueConnectionName != nil { 3114 ok := object.Key("GlueConnectionName") 3115 ok.String(*v.GlueConnectionName) 3116 } 3117 3118 if v.TempDirectory != nil { 3119 ok := object.Key("TempDirectory") 3120 if err := awsRestjson1_serializeDocumentS3Location(v.TempDirectory, ok); err != nil { 3121 return err 3122 } 3123 } 3124 3125 return nil 3126} 3127 3128func awsRestjson1_serializeDocumentDataCatalogInputDefinition(v *types.DataCatalogInputDefinition, value smithyjson.Value) error { 3129 object := value.Object() 3130 defer object.Close() 3131 3132 if v.CatalogId != nil { 3133 ok := object.Key("CatalogId") 3134 ok.String(*v.CatalogId) 3135 } 3136 3137 if v.DatabaseName != nil { 3138 ok := object.Key("DatabaseName") 3139 ok.String(*v.DatabaseName) 3140 } 3141 3142 if v.TableName != nil { 3143 ok := object.Key("TableName") 3144 ok.String(*v.TableName) 3145 } 3146 3147 if v.TempDirectory != nil { 3148 ok := object.Key("TempDirectory") 3149 if err := awsRestjson1_serializeDocumentS3Location(v.TempDirectory, ok); err != nil { 3150 return err 3151 } 3152 } 3153 3154 return nil 3155} 3156 3157func awsRestjson1_serializeDocumentDatasetParameter(v *types.DatasetParameter, value smithyjson.Value) error { 3158 object := value.Object() 3159 defer object.Close() 3160 3161 if v.CreateColumn { 3162 ok := object.Key("CreateColumn") 3163 ok.Boolean(v.CreateColumn) 3164 } 3165 3166 if v.DatetimeOptions != nil { 3167 ok := object.Key("DatetimeOptions") 3168 if err := awsRestjson1_serializeDocumentDatetimeOptions(v.DatetimeOptions, ok); err != nil { 3169 return err 3170 } 3171 } 3172 3173 if v.Filter != nil { 3174 ok := object.Key("Filter") 3175 if err := awsRestjson1_serializeDocumentFilterExpression(v.Filter, ok); err != nil { 3176 return err 3177 } 3178 } 3179 3180 if v.Name != nil { 3181 ok := object.Key("Name") 3182 ok.String(*v.Name) 3183 } 3184 3185 if len(v.Type) > 0 { 3186 ok := object.Key("Type") 3187 ok.String(string(v.Type)) 3188 } 3189 3190 return nil 3191} 3192 3193func awsRestjson1_serializeDocumentDatetimeOptions(v *types.DatetimeOptions, value smithyjson.Value) error { 3194 object := value.Object() 3195 defer object.Close() 3196 3197 if v.Format != nil { 3198 ok := object.Key("Format") 3199 ok.String(*v.Format) 3200 } 3201 3202 if v.LocaleCode != nil { 3203 ok := object.Key("LocaleCode") 3204 ok.String(*v.LocaleCode) 3205 } 3206 3207 if v.TimezoneOffset != nil { 3208 ok := object.Key("TimezoneOffset") 3209 ok.String(*v.TimezoneOffset) 3210 } 3211 3212 return nil 3213} 3214 3215func awsRestjson1_serializeDocumentExcelOptions(v *types.ExcelOptions, value smithyjson.Value) error { 3216 object := value.Object() 3217 defer object.Close() 3218 3219 if v.HeaderRow != nil { 3220 ok := object.Key("HeaderRow") 3221 ok.Boolean(*v.HeaderRow) 3222 } 3223 3224 if v.SheetIndexes != nil { 3225 ok := object.Key("SheetIndexes") 3226 if err := awsRestjson1_serializeDocumentSheetIndexList(v.SheetIndexes, ok); err != nil { 3227 return err 3228 } 3229 } 3230 3231 if v.SheetNames != nil { 3232 ok := object.Key("SheetNames") 3233 if err := awsRestjson1_serializeDocumentSheetNameList(v.SheetNames, ok); err != nil { 3234 return err 3235 } 3236 } 3237 3238 return nil 3239} 3240 3241func awsRestjson1_serializeDocumentFilesLimit(v *types.FilesLimit, value smithyjson.Value) error { 3242 object := value.Object() 3243 defer object.Close() 3244 3245 { 3246 ok := object.Key("MaxFiles") 3247 ok.Integer(v.MaxFiles) 3248 } 3249 3250 if len(v.Order) > 0 { 3251 ok := object.Key("Order") 3252 ok.String(string(v.Order)) 3253 } 3254 3255 if len(v.OrderedBy) > 0 { 3256 ok := object.Key("OrderedBy") 3257 ok.String(string(v.OrderedBy)) 3258 } 3259 3260 return nil 3261} 3262 3263func awsRestjson1_serializeDocumentFilterExpression(v *types.FilterExpression, value smithyjson.Value) error { 3264 object := value.Object() 3265 defer object.Close() 3266 3267 if v.Expression != nil { 3268 ok := object.Key("Expression") 3269 ok.String(*v.Expression) 3270 } 3271 3272 if v.ValuesMap != nil { 3273 ok := object.Key("ValuesMap") 3274 if err := awsRestjson1_serializeDocumentValuesMap(v.ValuesMap, ok); err != nil { 3275 return err 3276 } 3277 } 3278 3279 return nil 3280} 3281 3282func awsRestjson1_serializeDocumentFormatOptions(v *types.FormatOptions, value smithyjson.Value) error { 3283 object := value.Object() 3284 defer object.Close() 3285 3286 if v.Csv != nil { 3287 ok := object.Key("Csv") 3288 if err := awsRestjson1_serializeDocumentCsvOptions(v.Csv, ok); err != nil { 3289 return err 3290 } 3291 } 3292 3293 if v.Excel != nil { 3294 ok := object.Key("Excel") 3295 if err := awsRestjson1_serializeDocumentExcelOptions(v.Excel, ok); err != nil { 3296 return err 3297 } 3298 } 3299 3300 if v.Json != nil { 3301 ok := object.Key("Json") 3302 if err := awsRestjson1_serializeDocumentJsonOptions(v.Json, ok); err != nil { 3303 return err 3304 } 3305 } 3306 3307 return nil 3308} 3309 3310func awsRestjson1_serializeDocumentHiddenColumnList(v []string, value smithyjson.Value) error { 3311 array := value.Array() 3312 defer array.Close() 3313 3314 for i := range v { 3315 av := array.Value() 3316 av.String(v[i]) 3317 } 3318 return nil 3319} 3320 3321func awsRestjson1_serializeDocumentInput(v *types.Input, value smithyjson.Value) error { 3322 object := value.Object() 3323 defer object.Close() 3324 3325 if v.DatabaseInputDefinition != nil { 3326 ok := object.Key("DatabaseInputDefinition") 3327 if err := awsRestjson1_serializeDocumentDatabaseInputDefinition(v.DatabaseInputDefinition, ok); err != nil { 3328 return err 3329 } 3330 } 3331 3332 if v.DataCatalogInputDefinition != nil { 3333 ok := object.Key("DataCatalogInputDefinition") 3334 if err := awsRestjson1_serializeDocumentDataCatalogInputDefinition(v.DataCatalogInputDefinition, ok); err != nil { 3335 return err 3336 } 3337 } 3338 3339 if v.S3InputDefinition != nil { 3340 ok := object.Key("S3InputDefinition") 3341 if err := awsRestjson1_serializeDocumentS3Location(v.S3InputDefinition, ok); err != nil { 3342 return err 3343 } 3344 } 3345 3346 return nil 3347} 3348 3349func awsRestjson1_serializeDocumentJobNameList(v []string, value smithyjson.Value) error { 3350 array := value.Array() 3351 defer array.Close() 3352 3353 for i := range v { 3354 av := array.Value() 3355 av.String(v[i]) 3356 } 3357 return nil 3358} 3359 3360func awsRestjson1_serializeDocumentJobSample(v *types.JobSample, value smithyjson.Value) error { 3361 object := value.Object() 3362 defer object.Close() 3363 3364 if len(v.Mode) > 0 { 3365 ok := object.Key("Mode") 3366 ok.String(string(v.Mode)) 3367 } 3368 3369 if v.Size != nil { 3370 ok := object.Key("Size") 3371 ok.Long(*v.Size) 3372 } 3373 3374 return nil 3375} 3376 3377func awsRestjson1_serializeDocumentJsonOptions(v *types.JsonOptions, value smithyjson.Value) error { 3378 object := value.Object() 3379 defer object.Close() 3380 3381 if v.MultiLine { 3382 ok := object.Key("MultiLine") 3383 ok.Boolean(v.MultiLine) 3384 } 3385 3386 return nil 3387} 3388 3389func awsRestjson1_serializeDocumentOutput(v *types.Output, value smithyjson.Value) error { 3390 object := value.Object() 3391 defer object.Close() 3392 3393 if len(v.CompressionFormat) > 0 { 3394 ok := object.Key("CompressionFormat") 3395 ok.String(string(v.CompressionFormat)) 3396 } 3397 3398 if len(v.Format) > 0 { 3399 ok := object.Key("Format") 3400 ok.String(string(v.Format)) 3401 } 3402 3403 if v.FormatOptions != nil { 3404 ok := object.Key("FormatOptions") 3405 if err := awsRestjson1_serializeDocumentOutputFormatOptions(v.FormatOptions, ok); err != nil { 3406 return err 3407 } 3408 } 3409 3410 if v.Location != nil { 3411 ok := object.Key("Location") 3412 if err := awsRestjson1_serializeDocumentS3Location(v.Location, ok); err != nil { 3413 return err 3414 } 3415 } 3416 3417 if v.Overwrite { 3418 ok := object.Key("Overwrite") 3419 ok.Boolean(v.Overwrite) 3420 } 3421 3422 if v.PartitionColumns != nil { 3423 ok := object.Key("PartitionColumns") 3424 if err := awsRestjson1_serializeDocumentColumnNameList(v.PartitionColumns, ok); err != nil { 3425 return err 3426 } 3427 } 3428 3429 return nil 3430} 3431 3432func awsRestjson1_serializeDocumentOutputFormatOptions(v *types.OutputFormatOptions, value smithyjson.Value) error { 3433 object := value.Object() 3434 defer object.Close() 3435 3436 if v.Csv != nil { 3437 ok := object.Key("Csv") 3438 if err := awsRestjson1_serializeDocumentCsvOutputOptions(v.Csv, ok); err != nil { 3439 return err 3440 } 3441 } 3442 3443 return nil 3444} 3445 3446func awsRestjson1_serializeDocumentOutputList(v []types.Output, value smithyjson.Value) error { 3447 array := value.Array() 3448 defer array.Close() 3449 3450 for i := range v { 3451 av := array.Value() 3452 if err := awsRestjson1_serializeDocumentOutput(&v[i], av); err != nil { 3453 return err 3454 } 3455 } 3456 return nil 3457} 3458 3459func awsRestjson1_serializeDocumentParameterMap(v map[string]string, value smithyjson.Value) error { 3460 object := value.Object() 3461 defer object.Close() 3462 3463 for key := range v { 3464 om := object.Key(key) 3465 om.String(v[key]) 3466 } 3467 return nil 3468} 3469 3470func awsRestjson1_serializeDocumentPathOptions(v *types.PathOptions, value smithyjson.Value) error { 3471 object := value.Object() 3472 defer object.Close() 3473 3474 if v.FilesLimit != nil { 3475 ok := object.Key("FilesLimit") 3476 if err := awsRestjson1_serializeDocumentFilesLimit(v.FilesLimit, ok); err != nil { 3477 return err 3478 } 3479 } 3480 3481 if v.LastModifiedDateCondition != nil { 3482 ok := object.Key("LastModifiedDateCondition") 3483 if err := awsRestjson1_serializeDocumentFilterExpression(v.LastModifiedDateCondition, ok); err != nil { 3484 return err 3485 } 3486 } 3487 3488 if v.Parameters != nil { 3489 ok := object.Key("Parameters") 3490 if err := awsRestjson1_serializeDocumentPathParametersMap(v.Parameters, ok); err != nil { 3491 return err 3492 } 3493 } 3494 3495 return nil 3496} 3497 3498func awsRestjson1_serializeDocumentPathParametersMap(v map[string]types.DatasetParameter, value smithyjson.Value) error { 3499 object := value.Object() 3500 defer object.Close() 3501 3502 for key := range v { 3503 om := object.Key(key) 3504 mapVar := v[key] 3505 if err := awsRestjson1_serializeDocumentDatasetParameter(&mapVar, om); err != nil { 3506 return err 3507 } 3508 } 3509 return nil 3510} 3511 3512func awsRestjson1_serializeDocumentRecipeAction(v *types.RecipeAction, value smithyjson.Value) error { 3513 object := value.Object() 3514 defer object.Close() 3515 3516 if v.Operation != nil { 3517 ok := object.Key("Operation") 3518 ok.String(*v.Operation) 3519 } 3520 3521 if v.Parameters != nil { 3522 ok := object.Key("Parameters") 3523 if err := awsRestjson1_serializeDocumentParameterMap(v.Parameters, ok); err != nil { 3524 return err 3525 } 3526 } 3527 3528 return nil 3529} 3530 3531func awsRestjson1_serializeDocumentRecipeReference(v *types.RecipeReference, value smithyjson.Value) error { 3532 object := value.Object() 3533 defer object.Close() 3534 3535 if v.Name != nil { 3536 ok := object.Key("Name") 3537 ok.String(*v.Name) 3538 } 3539 3540 if v.RecipeVersion != nil { 3541 ok := object.Key("RecipeVersion") 3542 ok.String(*v.RecipeVersion) 3543 } 3544 3545 return nil 3546} 3547 3548func awsRestjson1_serializeDocumentRecipeStep(v *types.RecipeStep, value smithyjson.Value) error { 3549 object := value.Object() 3550 defer object.Close() 3551 3552 if v.Action != nil { 3553 ok := object.Key("Action") 3554 if err := awsRestjson1_serializeDocumentRecipeAction(v.Action, ok); err != nil { 3555 return err 3556 } 3557 } 3558 3559 if v.ConditionExpressions != nil { 3560 ok := object.Key("ConditionExpressions") 3561 if err := awsRestjson1_serializeDocumentConditionExpressionList(v.ConditionExpressions, ok); err != nil { 3562 return err 3563 } 3564 } 3565 3566 return nil 3567} 3568 3569func awsRestjson1_serializeDocumentRecipeStepList(v []types.RecipeStep, value smithyjson.Value) error { 3570 array := value.Array() 3571 defer array.Close() 3572 3573 for i := range v { 3574 av := array.Value() 3575 if err := awsRestjson1_serializeDocumentRecipeStep(&v[i], av); err != nil { 3576 return err 3577 } 3578 } 3579 return nil 3580} 3581 3582func awsRestjson1_serializeDocumentRecipeVersionList(v []string, value smithyjson.Value) error { 3583 array := value.Array() 3584 defer array.Close() 3585 3586 for i := range v { 3587 av := array.Value() 3588 av.String(v[i]) 3589 } 3590 return nil 3591} 3592 3593func awsRestjson1_serializeDocumentS3Location(v *types.S3Location, value smithyjson.Value) error { 3594 object := value.Object() 3595 defer object.Close() 3596 3597 if v.Bucket != nil { 3598 ok := object.Key("Bucket") 3599 ok.String(*v.Bucket) 3600 } 3601 3602 if v.Key != nil { 3603 ok := object.Key("Key") 3604 ok.String(*v.Key) 3605 } 3606 3607 return nil 3608} 3609 3610func awsRestjson1_serializeDocumentSample(v *types.Sample, value smithyjson.Value) error { 3611 object := value.Object() 3612 defer object.Close() 3613 3614 if v.Size != nil { 3615 ok := object.Key("Size") 3616 ok.Integer(*v.Size) 3617 } 3618 3619 if len(v.Type) > 0 { 3620 ok := object.Key("Type") 3621 ok.String(string(v.Type)) 3622 } 3623 3624 return nil 3625} 3626 3627func awsRestjson1_serializeDocumentSheetIndexList(v []int32, value smithyjson.Value) error { 3628 array := value.Array() 3629 defer array.Close() 3630 3631 for i := range v { 3632 av := array.Value() 3633 av.Integer(v[i]) 3634 } 3635 return nil 3636} 3637 3638func awsRestjson1_serializeDocumentSheetNameList(v []string, value smithyjson.Value) error { 3639 array := value.Array() 3640 defer array.Close() 3641 3642 for i := range v { 3643 av := array.Value() 3644 av.String(v[i]) 3645 } 3646 return nil 3647} 3648 3649func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error { 3650 object := value.Object() 3651 defer object.Close() 3652 3653 for key := range v { 3654 om := object.Key(key) 3655 om.String(v[key]) 3656 } 3657 return nil 3658} 3659 3660func awsRestjson1_serializeDocumentValuesMap(v map[string]string, value smithyjson.Value) error { 3661 object := value.Object() 3662 defer object.Close() 3663 3664 for key := range v { 3665 om := object.Key(key) 3666 om.String(v[key]) 3667 } 3668 return nil 3669} 3670 3671func awsRestjson1_serializeDocumentViewFrame(v *types.ViewFrame, value smithyjson.Value) error { 3672 object := value.Object() 3673 defer object.Close() 3674 3675 if v.ColumnRange != nil { 3676 ok := object.Key("ColumnRange") 3677 ok.Integer(*v.ColumnRange) 3678 } 3679 3680 if v.HiddenColumns != nil { 3681 ok := object.Key("HiddenColumns") 3682 if err := awsRestjson1_serializeDocumentHiddenColumnList(v.HiddenColumns, ok); err != nil { 3683 return err 3684 } 3685 } 3686 3687 if v.StartColumnIndex != nil { 3688 ok := object.Key("StartColumnIndex") 3689 ok.Integer(*v.StartColumnIndex) 3690 } 3691 3692 return nil 3693} 3694