1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package sesv2 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/sesv2/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 smithytime "github.com/aws/smithy-go/time" 15 smithyhttp "github.com/aws/smithy-go/transport/http" 16) 17 18type awsRestjson1_serializeOpCreateConfigurationSet struct { 19} 20 21func (*awsRestjson1_serializeOpCreateConfigurationSet) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsRestjson1_serializeOpCreateConfigurationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 26 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 27) { 28 request, ok := in.Request.(*smithyhttp.Request) 29 if !ok { 30 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 31 } 32 33 input, ok := in.Parameters.(*CreateConfigurationSetInput) 34 _ = input 35 if !ok { 36 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 37 } 38 39 opPath, opQuery := httpbinding.SplitURI("/v2/email/configuration-sets") 40 request.URL.Path = opPath 41 if len(request.URL.RawQuery) > 0 { 42 request.URL.RawQuery = "&" + opQuery 43 } else { 44 request.URL.RawQuery = opQuery 45 } 46 47 request.Method = "POST" 48 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 49 if err != nil { 50 return out, metadata, &smithy.SerializationError{Err: err} 51 } 52 53 restEncoder.SetHeader("Content-Type").String("application/json") 54 55 jsonEncoder := smithyjson.NewEncoder() 56 if err := awsRestjson1_serializeOpDocumentCreateConfigurationSetInput(input, jsonEncoder.Value); err != nil { 57 return out, metadata, &smithy.SerializationError{Err: err} 58 } 59 60 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 61 return out, metadata, &smithy.SerializationError{Err: err} 62 } 63 64 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 65 return out, metadata, &smithy.SerializationError{Err: err} 66 } 67 in.Request = request 68 69 return next.HandleSerialize(ctx, in) 70} 71func awsRestjson1_serializeOpHttpBindingsCreateConfigurationSetInput(v *CreateConfigurationSetInput, encoder *httpbinding.Encoder) error { 72 if v == nil { 73 return fmt.Errorf("unsupported serialization of nil %T", v) 74 } 75 76 return nil 77} 78 79func awsRestjson1_serializeOpDocumentCreateConfigurationSetInput(v *CreateConfigurationSetInput, value smithyjson.Value) error { 80 object := value.Object() 81 defer object.Close() 82 83 if v.ConfigurationSetName != nil { 84 ok := object.Key("ConfigurationSetName") 85 ok.String(*v.ConfigurationSetName) 86 } 87 88 if v.DeliveryOptions != nil { 89 ok := object.Key("DeliveryOptions") 90 if err := awsRestjson1_serializeDocumentDeliveryOptions(v.DeliveryOptions, ok); err != nil { 91 return err 92 } 93 } 94 95 if v.ReputationOptions != nil { 96 ok := object.Key("ReputationOptions") 97 if err := awsRestjson1_serializeDocumentReputationOptions(v.ReputationOptions, ok); err != nil { 98 return err 99 } 100 } 101 102 if v.SendingOptions != nil { 103 ok := object.Key("SendingOptions") 104 if err := awsRestjson1_serializeDocumentSendingOptions(v.SendingOptions, ok); err != nil { 105 return err 106 } 107 } 108 109 if v.SuppressionOptions != nil { 110 ok := object.Key("SuppressionOptions") 111 if err := awsRestjson1_serializeDocumentSuppressionOptions(v.SuppressionOptions, ok); err != nil { 112 return err 113 } 114 } 115 116 if v.Tags != nil { 117 ok := object.Key("Tags") 118 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 119 return err 120 } 121 } 122 123 if v.TrackingOptions != nil { 124 ok := object.Key("TrackingOptions") 125 if err := awsRestjson1_serializeDocumentTrackingOptions(v.TrackingOptions, ok); err != nil { 126 return err 127 } 128 } 129 130 return nil 131} 132 133type awsRestjson1_serializeOpCreateConfigurationSetEventDestination struct { 134} 135 136func (*awsRestjson1_serializeOpCreateConfigurationSetEventDestination) ID() string { 137 return "OperationSerializer" 138} 139 140func (m *awsRestjson1_serializeOpCreateConfigurationSetEventDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 141 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 142) { 143 request, ok := in.Request.(*smithyhttp.Request) 144 if !ok { 145 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 146 } 147 148 input, ok := in.Parameters.(*CreateConfigurationSetEventDestinationInput) 149 _ = input 150 if !ok { 151 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 152 } 153 154 opPath, opQuery := httpbinding.SplitURI("/v2/email/configuration-sets/{ConfigurationSetName}/event-destinations") 155 request.URL.Path = opPath 156 if len(request.URL.RawQuery) > 0 { 157 request.URL.RawQuery = "&" + opQuery 158 } else { 159 request.URL.RawQuery = opQuery 160 } 161 162 request.Method = "POST" 163 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 164 if err != nil { 165 return out, metadata, &smithy.SerializationError{Err: err} 166 } 167 168 if err := awsRestjson1_serializeOpHttpBindingsCreateConfigurationSetEventDestinationInput(input, restEncoder); err != nil { 169 return out, metadata, &smithy.SerializationError{Err: err} 170 } 171 172 restEncoder.SetHeader("Content-Type").String("application/json") 173 174 jsonEncoder := smithyjson.NewEncoder() 175 if err := awsRestjson1_serializeOpDocumentCreateConfigurationSetEventDestinationInput(input, jsonEncoder.Value); err != nil { 176 return out, metadata, &smithy.SerializationError{Err: err} 177 } 178 179 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 180 return out, metadata, &smithy.SerializationError{Err: err} 181 } 182 183 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 184 return out, metadata, &smithy.SerializationError{Err: err} 185 } 186 in.Request = request 187 188 return next.HandleSerialize(ctx, in) 189} 190func awsRestjson1_serializeOpHttpBindingsCreateConfigurationSetEventDestinationInput(v *CreateConfigurationSetEventDestinationInput, encoder *httpbinding.Encoder) error { 191 if v == nil { 192 return fmt.Errorf("unsupported serialization of nil %T", v) 193 } 194 195 if v.ConfigurationSetName == nil || len(*v.ConfigurationSetName) == 0 { 196 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationSetName must not be empty")} 197 } 198 if v.ConfigurationSetName != nil { 199 if err := encoder.SetURI("ConfigurationSetName").String(*v.ConfigurationSetName); err != nil { 200 return err 201 } 202 } 203 204 return nil 205} 206 207func awsRestjson1_serializeOpDocumentCreateConfigurationSetEventDestinationInput(v *CreateConfigurationSetEventDestinationInput, value smithyjson.Value) error { 208 object := value.Object() 209 defer object.Close() 210 211 if v.EventDestination != nil { 212 ok := object.Key("EventDestination") 213 if err := awsRestjson1_serializeDocumentEventDestinationDefinition(v.EventDestination, ok); err != nil { 214 return err 215 } 216 } 217 218 if v.EventDestinationName != nil { 219 ok := object.Key("EventDestinationName") 220 ok.String(*v.EventDestinationName) 221 } 222 223 return nil 224} 225 226type awsRestjson1_serializeOpCreateContact struct { 227} 228 229func (*awsRestjson1_serializeOpCreateContact) ID() string { 230 return "OperationSerializer" 231} 232 233func (m *awsRestjson1_serializeOpCreateContact) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 234 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 235) { 236 request, ok := in.Request.(*smithyhttp.Request) 237 if !ok { 238 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 239 } 240 241 input, ok := in.Parameters.(*CreateContactInput) 242 _ = input 243 if !ok { 244 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 245 } 246 247 opPath, opQuery := httpbinding.SplitURI("/v2/email/contact-lists/{ContactListName}/contacts") 248 request.URL.Path = opPath 249 if len(request.URL.RawQuery) > 0 { 250 request.URL.RawQuery = "&" + opQuery 251 } else { 252 request.URL.RawQuery = opQuery 253 } 254 255 request.Method = "POST" 256 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 257 if err != nil { 258 return out, metadata, &smithy.SerializationError{Err: err} 259 } 260 261 if err := awsRestjson1_serializeOpHttpBindingsCreateContactInput(input, restEncoder); err != nil { 262 return out, metadata, &smithy.SerializationError{Err: err} 263 } 264 265 restEncoder.SetHeader("Content-Type").String("application/json") 266 267 jsonEncoder := smithyjson.NewEncoder() 268 if err := awsRestjson1_serializeOpDocumentCreateContactInput(input, jsonEncoder.Value); err != nil { 269 return out, metadata, &smithy.SerializationError{Err: err} 270 } 271 272 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 273 return out, metadata, &smithy.SerializationError{Err: err} 274 } 275 276 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 277 return out, metadata, &smithy.SerializationError{Err: err} 278 } 279 in.Request = request 280 281 return next.HandleSerialize(ctx, in) 282} 283func awsRestjson1_serializeOpHttpBindingsCreateContactInput(v *CreateContactInput, encoder *httpbinding.Encoder) error { 284 if v == nil { 285 return fmt.Errorf("unsupported serialization of nil %T", v) 286 } 287 288 if v.ContactListName == nil || len(*v.ContactListName) == 0 { 289 return &smithy.SerializationError{Err: fmt.Errorf("input member ContactListName must not be empty")} 290 } 291 if v.ContactListName != nil { 292 if err := encoder.SetURI("ContactListName").String(*v.ContactListName); err != nil { 293 return err 294 } 295 } 296 297 return nil 298} 299 300func awsRestjson1_serializeOpDocumentCreateContactInput(v *CreateContactInput, value smithyjson.Value) error { 301 object := value.Object() 302 defer object.Close() 303 304 if v.AttributesData != nil { 305 ok := object.Key("AttributesData") 306 ok.String(*v.AttributesData) 307 } 308 309 if v.EmailAddress != nil { 310 ok := object.Key("EmailAddress") 311 ok.String(*v.EmailAddress) 312 } 313 314 if v.TopicPreferences != nil { 315 ok := object.Key("TopicPreferences") 316 if err := awsRestjson1_serializeDocumentTopicPreferenceList(v.TopicPreferences, ok); err != nil { 317 return err 318 } 319 } 320 321 if v.UnsubscribeAll { 322 ok := object.Key("UnsubscribeAll") 323 ok.Boolean(v.UnsubscribeAll) 324 } 325 326 return nil 327} 328 329type awsRestjson1_serializeOpCreateContactList struct { 330} 331 332func (*awsRestjson1_serializeOpCreateContactList) ID() string { 333 return "OperationSerializer" 334} 335 336func (m *awsRestjson1_serializeOpCreateContactList) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 337 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 338) { 339 request, ok := in.Request.(*smithyhttp.Request) 340 if !ok { 341 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 342 } 343 344 input, ok := in.Parameters.(*CreateContactListInput) 345 _ = input 346 if !ok { 347 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 348 } 349 350 opPath, opQuery := httpbinding.SplitURI("/v2/email/contact-lists") 351 request.URL.Path = opPath 352 if len(request.URL.RawQuery) > 0 { 353 request.URL.RawQuery = "&" + opQuery 354 } else { 355 request.URL.RawQuery = opQuery 356 } 357 358 request.Method = "POST" 359 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 360 if err != nil { 361 return out, metadata, &smithy.SerializationError{Err: err} 362 } 363 364 restEncoder.SetHeader("Content-Type").String("application/json") 365 366 jsonEncoder := smithyjson.NewEncoder() 367 if err := awsRestjson1_serializeOpDocumentCreateContactListInput(input, jsonEncoder.Value); err != nil { 368 return out, metadata, &smithy.SerializationError{Err: err} 369 } 370 371 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 372 return out, metadata, &smithy.SerializationError{Err: err} 373 } 374 375 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 376 return out, metadata, &smithy.SerializationError{Err: err} 377 } 378 in.Request = request 379 380 return next.HandleSerialize(ctx, in) 381} 382func awsRestjson1_serializeOpHttpBindingsCreateContactListInput(v *CreateContactListInput, encoder *httpbinding.Encoder) error { 383 if v == nil { 384 return fmt.Errorf("unsupported serialization of nil %T", v) 385 } 386 387 return nil 388} 389 390func awsRestjson1_serializeOpDocumentCreateContactListInput(v *CreateContactListInput, value smithyjson.Value) error { 391 object := value.Object() 392 defer object.Close() 393 394 if v.ContactListName != nil { 395 ok := object.Key("ContactListName") 396 ok.String(*v.ContactListName) 397 } 398 399 if v.Description != nil { 400 ok := object.Key("Description") 401 ok.String(*v.Description) 402 } 403 404 if v.Tags != nil { 405 ok := object.Key("Tags") 406 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 407 return err 408 } 409 } 410 411 if v.Topics != nil { 412 ok := object.Key("Topics") 413 if err := awsRestjson1_serializeDocumentTopics(v.Topics, ok); err != nil { 414 return err 415 } 416 } 417 418 return nil 419} 420 421type awsRestjson1_serializeOpCreateCustomVerificationEmailTemplate struct { 422} 423 424func (*awsRestjson1_serializeOpCreateCustomVerificationEmailTemplate) ID() string { 425 return "OperationSerializer" 426} 427 428func (m *awsRestjson1_serializeOpCreateCustomVerificationEmailTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 429 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 430) { 431 request, ok := in.Request.(*smithyhttp.Request) 432 if !ok { 433 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 434 } 435 436 input, ok := in.Parameters.(*CreateCustomVerificationEmailTemplateInput) 437 _ = input 438 if !ok { 439 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 440 } 441 442 opPath, opQuery := httpbinding.SplitURI("/v2/email/custom-verification-email-templates") 443 request.URL.Path = opPath 444 if len(request.URL.RawQuery) > 0 { 445 request.URL.RawQuery = "&" + opQuery 446 } else { 447 request.URL.RawQuery = opQuery 448 } 449 450 request.Method = "POST" 451 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 452 if err != nil { 453 return out, metadata, &smithy.SerializationError{Err: err} 454 } 455 456 restEncoder.SetHeader("Content-Type").String("application/json") 457 458 jsonEncoder := smithyjson.NewEncoder() 459 if err := awsRestjson1_serializeOpDocumentCreateCustomVerificationEmailTemplateInput(input, jsonEncoder.Value); err != nil { 460 return out, metadata, &smithy.SerializationError{Err: err} 461 } 462 463 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 464 return out, metadata, &smithy.SerializationError{Err: err} 465 } 466 467 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 468 return out, metadata, &smithy.SerializationError{Err: err} 469 } 470 in.Request = request 471 472 return next.HandleSerialize(ctx, in) 473} 474func awsRestjson1_serializeOpHttpBindingsCreateCustomVerificationEmailTemplateInput(v *CreateCustomVerificationEmailTemplateInput, encoder *httpbinding.Encoder) error { 475 if v == nil { 476 return fmt.Errorf("unsupported serialization of nil %T", v) 477 } 478 479 return nil 480} 481 482func awsRestjson1_serializeOpDocumentCreateCustomVerificationEmailTemplateInput(v *CreateCustomVerificationEmailTemplateInput, value smithyjson.Value) error { 483 object := value.Object() 484 defer object.Close() 485 486 if v.FailureRedirectionURL != nil { 487 ok := object.Key("FailureRedirectionURL") 488 ok.String(*v.FailureRedirectionURL) 489 } 490 491 if v.FromEmailAddress != nil { 492 ok := object.Key("FromEmailAddress") 493 ok.String(*v.FromEmailAddress) 494 } 495 496 if v.SuccessRedirectionURL != nil { 497 ok := object.Key("SuccessRedirectionURL") 498 ok.String(*v.SuccessRedirectionURL) 499 } 500 501 if v.TemplateContent != nil { 502 ok := object.Key("TemplateContent") 503 ok.String(*v.TemplateContent) 504 } 505 506 if v.TemplateName != nil { 507 ok := object.Key("TemplateName") 508 ok.String(*v.TemplateName) 509 } 510 511 if v.TemplateSubject != nil { 512 ok := object.Key("TemplateSubject") 513 ok.String(*v.TemplateSubject) 514 } 515 516 return nil 517} 518 519type awsRestjson1_serializeOpCreateDedicatedIpPool struct { 520} 521 522func (*awsRestjson1_serializeOpCreateDedicatedIpPool) ID() string { 523 return "OperationSerializer" 524} 525 526func (m *awsRestjson1_serializeOpCreateDedicatedIpPool) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 527 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 528) { 529 request, ok := in.Request.(*smithyhttp.Request) 530 if !ok { 531 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 532 } 533 534 input, ok := in.Parameters.(*CreateDedicatedIpPoolInput) 535 _ = input 536 if !ok { 537 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 538 } 539 540 opPath, opQuery := httpbinding.SplitURI("/v2/email/dedicated-ip-pools") 541 request.URL.Path = opPath 542 if len(request.URL.RawQuery) > 0 { 543 request.URL.RawQuery = "&" + opQuery 544 } else { 545 request.URL.RawQuery = opQuery 546 } 547 548 request.Method = "POST" 549 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 550 if err != nil { 551 return out, metadata, &smithy.SerializationError{Err: err} 552 } 553 554 restEncoder.SetHeader("Content-Type").String("application/json") 555 556 jsonEncoder := smithyjson.NewEncoder() 557 if err := awsRestjson1_serializeOpDocumentCreateDedicatedIpPoolInput(input, jsonEncoder.Value); err != nil { 558 return out, metadata, &smithy.SerializationError{Err: err} 559 } 560 561 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 562 return out, metadata, &smithy.SerializationError{Err: err} 563 } 564 565 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 566 return out, metadata, &smithy.SerializationError{Err: err} 567 } 568 in.Request = request 569 570 return next.HandleSerialize(ctx, in) 571} 572func awsRestjson1_serializeOpHttpBindingsCreateDedicatedIpPoolInput(v *CreateDedicatedIpPoolInput, encoder *httpbinding.Encoder) error { 573 if v == nil { 574 return fmt.Errorf("unsupported serialization of nil %T", v) 575 } 576 577 return nil 578} 579 580func awsRestjson1_serializeOpDocumentCreateDedicatedIpPoolInput(v *CreateDedicatedIpPoolInput, value smithyjson.Value) error { 581 object := value.Object() 582 defer object.Close() 583 584 if v.PoolName != nil { 585 ok := object.Key("PoolName") 586 ok.String(*v.PoolName) 587 } 588 589 if v.Tags != nil { 590 ok := object.Key("Tags") 591 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 592 return err 593 } 594 } 595 596 return nil 597} 598 599type awsRestjson1_serializeOpCreateDeliverabilityTestReport struct { 600} 601 602func (*awsRestjson1_serializeOpCreateDeliverabilityTestReport) ID() string { 603 return "OperationSerializer" 604} 605 606func (m *awsRestjson1_serializeOpCreateDeliverabilityTestReport) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 607 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 608) { 609 request, ok := in.Request.(*smithyhttp.Request) 610 if !ok { 611 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 612 } 613 614 input, ok := in.Parameters.(*CreateDeliverabilityTestReportInput) 615 _ = input 616 if !ok { 617 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 618 } 619 620 opPath, opQuery := httpbinding.SplitURI("/v2/email/deliverability-dashboard/test") 621 request.URL.Path = opPath 622 if len(request.URL.RawQuery) > 0 { 623 request.URL.RawQuery = "&" + opQuery 624 } else { 625 request.URL.RawQuery = opQuery 626 } 627 628 request.Method = "POST" 629 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 630 if err != nil { 631 return out, metadata, &smithy.SerializationError{Err: err} 632 } 633 634 restEncoder.SetHeader("Content-Type").String("application/json") 635 636 jsonEncoder := smithyjson.NewEncoder() 637 if err := awsRestjson1_serializeOpDocumentCreateDeliverabilityTestReportInput(input, jsonEncoder.Value); err != nil { 638 return out, metadata, &smithy.SerializationError{Err: err} 639 } 640 641 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 642 return out, metadata, &smithy.SerializationError{Err: err} 643 } 644 645 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 646 return out, metadata, &smithy.SerializationError{Err: err} 647 } 648 in.Request = request 649 650 return next.HandleSerialize(ctx, in) 651} 652func awsRestjson1_serializeOpHttpBindingsCreateDeliverabilityTestReportInput(v *CreateDeliverabilityTestReportInput, encoder *httpbinding.Encoder) error { 653 if v == nil { 654 return fmt.Errorf("unsupported serialization of nil %T", v) 655 } 656 657 return nil 658} 659 660func awsRestjson1_serializeOpDocumentCreateDeliverabilityTestReportInput(v *CreateDeliverabilityTestReportInput, value smithyjson.Value) error { 661 object := value.Object() 662 defer object.Close() 663 664 if v.Content != nil { 665 ok := object.Key("Content") 666 if err := awsRestjson1_serializeDocumentEmailContent(v.Content, ok); err != nil { 667 return err 668 } 669 } 670 671 if v.FromEmailAddress != nil { 672 ok := object.Key("FromEmailAddress") 673 ok.String(*v.FromEmailAddress) 674 } 675 676 if v.ReportName != nil { 677 ok := object.Key("ReportName") 678 ok.String(*v.ReportName) 679 } 680 681 if v.Tags != nil { 682 ok := object.Key("Tags") 683 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 684 return err 685 } 686 } 687 688 return nil 689} 690 691type awsRestjson1_serializeOpCreateEmailIdentity struct { 692} 693 694func (*awsRestjson1_serializeOpCreateEmailIdentity) ID() string { 695 return "OperationSerializer" 696} 697 698func (m *awsRestjson1_serializeOpCreateEmailIdentity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 699 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 700) { 701 request, ok := in.Request.(*smithyhttp.Request) 702 if !ok { 703 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 704 } 705 706 input, ok := in.Parameters.(*CreateEmailIdentityInput) 707 _ = input 708 if !ok { 709 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 710 } 711 712 opPath, opQuery := httpbinding.SplitURI("/v2/email/identities") 713 request.URL.Path = opPath 714 if len(request.URL.RawQuery) > 0 { 715 request.URL.RawQuery = "&" + opQuery 716 } else { 717 request.URL.RawQuery = opQuery 718 } 719 720 request.Method = "POST" 721 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 722 if err != nil { 723 return out, metadata, &smithy.SerializationError{Err: err} 724 } 725 726 restEncoder.SetHeader("Content-Type").String("application/json") 727 728 jsonEncoder := smithyjson.NewEncoder() 729 if err := awsRestjson1_serializeOpDocumentCreateEmailIdentityInput(input, jsonEncoder.Value); err != nil { 730 return out, metadata, &smithy.SerializationError{Err: err} 731 } 732 733 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 734 return out, metadata, &smithy.SerializationError{Err: err} 735 } 736 737 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 738 return out, metadata, &smithy.SerializationError{Err: err} 739 } 740 in.Request = request 741 742 return next.HandleSerialize(ctx, in) 743} 744func awsRestjson1_serializeOpHttpBindingsCreateEmailIdentityInput(v *CreateEmailIdentityInput, encoder *httpbinding.Encoder) error { 745 if v == nil { 746 return fmt.Errorf("unsupported serialization of nil %T", v) 747 } 748 749 return nil 750} 751 752func awsRestjson1_serializeOpDocumentCreateEmailIdentityInput(v *CreateEmailIdentityInput, value smithyjson.Value) error { 753 object := value.Object() 754 defer object.Close() 755 756 if v.DkimSigningAttributes != nil { 757 ok := object.Key("DkimSigningAttributes") 758 if err := awsRestjson1_serializeDocumentDkimSigningAttributes(v.DkimSigningAttributes, ok); err != nil { 759 return err 760 } 761 } 762 763 if v.EmailIdentity != nil { 764 ok := object.Key("EmailIdentity") 765 ok.String(*v.EmailIdentity) 766 } 767 768 if v.Tags != nil { 769 ok := object.Key("Tags") 770 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 771 return err 772 } 773 } 774 775 return nil 776} 777 778type awsRestjson1_serializeOpCreateEmailIdentityPolicy struct { 779} 780 781func (*awsRestjson1_serializeOpCreateEmailIdentityPolicy) ID() string { 782 return "OperationSerializer" 783} 784 785func (m *awsRestjson1_serializeOpCreateEmailIdentityPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 786 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 787) { 788 request, ok := in.Request.(*smithyhttp.Request) 789 if !ok { 790 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 791 } 792 793 input, ok := in.Parameters.(*CreateEmailIdentityPolicyInput) 794 _ = input 795 if !ok { 796 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 797 } 798 799 opPath, opQuery := httpbinding.SplitURI("/v2/email/identities/{EmailIdentity}/policies/{PolicyName}") 800 request.URL.Path = opPath 801 if len(request.URL.RawQuery) > 0 { 802 request.URL.RawQuery = "&" + opQuery 803 } else { 804 request.URL.RawQuery = opQuery 805 } 806 807 request.Method = "POST" 808 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 809 if err != nil { 810 return out, metadata, &smithy.SerializationError{Err: err} 811 } 812 813 if err := awsRestjson1_serializeOpHttpBindingsCreateEmailIdentityPolicyInput(input, restEncoder); err != nil { 814 return out, metadata, &smithy.SerializationError{Err: err} 815 } 816 817 restEncoder.SetHeader("Content-Type").String("application/json") 818 819 jsonEncoder := smithyjson.NewEncoder() 820 if err := awsRestjson1_serializeOpDocumentCreateEmailIdentityPolicyInput(input, jsonEncoder.Value); err != nil { 821 return out, metadata, &smithy.SerializationError{Err: err} 822 } 823 824 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 825 return out, metadata, &smithy.SerializationError{Err: err} 826 } 827 828 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 829 return out, metadata, &smithy.SerializationError{Err: err} 830 } 831 in.Request = request 832 833 return next.HandleSerialize(ctx, in) 834} 835func awsRestjson1_serializeOpHttpBindingsCreateEmailIdentityPolicyInput(v *CreateEmailIdentityPolicyInput, encoder *httpbinding.Encoder) error { 836 if v == nil { 837 return fmt.Errorf("unsupported serialization of nil %T", v) 838 } 839 840 if v.EmailIdentity == nil || len(*v.EmailIdentity) == 0 { 841 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailIdentity must not be empty")} 842 } 843 if v.EmailIdentity != nil { 844 if err := encoder.SetURI("EmailIdentity").String(*v.EmailIdentity); err != nil { 845 return err 846 } 847 } 848 849 if v.PolicyName == nil || len(*v.PolicyName) == 0 { 850 return &smithy.SerializationError{Err: fmt.Errorf("input member PolicyName must not be empty")} 851 } 852 if v.PolicyName != nil { 853 if err := encoder.SetURI("PolicyName").String(*v.PolicyName); err != nil { 854 return err 855 } 856 } 857 858 return nil 859} 860 861func awsRestjson1_serializeOpDocumentCreateEmailIdentityPolicyInput(v *CreateEmailIdentityPolicyInput, value smithyjson.Value) error { 862 object := value.Object() 863 defer object.Close() 864 865 if v.Policy != nil { 866 ok := object.Key("Policy") 867 ok.String(*v.Policy) 868 } 869 870 return nil 871} 872 873type awsRestjson1_serializeOpCreateEmailTemplate struct { 874} 875 876func (*awsRestjson1_serializeOpCreateEmailTemplate) ID() string { 877 return "OperationSerializer" 878} 879 880func (m *awsRestjson1_serializeOpCreateEmailTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 881 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 882) { 883 request, ok := in.Request.(*smithyhttp.Request) 884 if !ok { 885 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 886 } 887 888 input, ok := in.Parameters.(*CreateEmailTemplateInput) 889 _ = input 890 if !ok { 891 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 892 } 893 894 opPath, opQuery := httpbinding.SplitURI("/v2/email/templates") 895 request.URL.Path = opPath 896 if len(request.URL.RawQuery) > 0 { 897 request.URL.RawQuery = "&" + opQuery 898 } else { 899 request.URL.RawQuery = opQuery 900 } 901 902 request.Method = "POST" 903 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 904 if err != nil { 905 return out, metadata, &smithy.SerializationError{Err: err} 906 } 907 908 restEncoder.SetHeader("Content-Type").String("application/json") 909 910 jsonEncoder := smithyjson.NewEncoder() 911 if err := awsRestjson1_serializeOpDocumentCreateEmailTemplateInput(input, jsonEncoder.Value); err != nil { 912 return out, metadata, &smithy.SerializationError{Err: err} 913 } 914 915 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 916 return out, metadata, &smithy.SerializationError{Err: err} 917 } 918 919 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 920 return out, metadata, &smithy.SerializationError{Err: err} 921 } 922 in.Request = request 923 924 return next.HandleSerialize(ctx, in) 925} 926func awsRestjson1_serializeOpHttpBindingsCreateEmailTemplateInput(v *CreateEmailTemplateInput, encoder *httpbinding.Encoder) error { 927 if v == nil { 928 return fmt.Errorf("unsupported serialization of nil %T", v) 929 } 930 931 return nil 932} 933 934func awsRestjson1_serializeOpDocumentCreateEmailTemplateInput(v *CreateEmailTemplateInput, value smithyjson.Value) error { 935 object := value.Object() 936 defer object.Close() 937 938 if v.TemplateContent != nil { 939 ok := object.Key("TemplateContent") 940 if err := awsRestjson1_serializeDocumentEmailTemplateContent(v.TemplateContent, ok); err != nil { 941 return err 942 } 943 } 944 945 if v.TemplateName != nil { 946 ok := object.Key("TemplateName") 947 ok.String(*v.TemplateName) 948 } 949 950 return nil 951} 952 953type awsRestjson1_serializeOpCreateImportJob struct { 954} 955 956func (*awsRestjson1_serializeOpCreateImportJob) ID() string { 957 return "OperationSerializer" 958} 959 960func (m *awsRestjson1_serializeOpCreateImportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 961 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 962) { 963 request, ok := in.Request.(*smithyhttp.Request) 964 if !ok { 965 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 966 } 967 968 input, ok := in.Parameters.(*CreateImportJobInput) 969 _ = input 970 if !ok { 971 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 972 } 973 974 opPath, opQuery := httpbinding.SplitURI("/v2/email/import-jobs") 975 request.URL.Path = opPath 976 if len(request.URL.RawQuery) > 0 { 977 request.URL.RawQuery = "&" + opQuery 978 } else { 979 request.URL.RawQuery = opQuery 980 } 981 982 request.Method = "POST" 983 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 984 if err != nil { 985 return out, metadata, &smithy.SerializationError{Err: err} 986 } 987 988 restEncoder.SetHeader("Content-Type").String("application/json") 989 990 jsonEncoder := smithyjson.NewEncoder() 991 if err := awsRestjson1_serializeOpDocumentCreateImportJobInput(input, jsonEncoder.Value); err != nil { 992 return out, metadata, &smithy.SerializationError{Err: err} 993 } 994 995 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 996 return out, metadata, &smithy.SerializationError{Err: err} 997 } 998 999 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1000 return out, metadata, &smithy.SerializationError{Err: err} 1001 } 1002 in.Request = request 1003 1004 return next.HandleSerialize(ctx, in) 1005} 1006func awsRestjson1_serializeOpHttpBindingsCreateImportJobInput(v *CreateImportJobInput, encoder *httpbinding.Encoder) error { 1007 if v == nil { 1008 return fmt.Errorf("unsupported serialization of nil %T", v) 1009 } 1010 1011 return nil 1012} 1013 1014func awsRestjson1_serializeOpDocumentCreateImportJobInput(v *CreateImportJobInput, value smithyjson.Value) error { 1015 object := value.Object() 1016 defer object.Close() 1017 1018 if v.ImportDataSource != nil { 1019 ok := object.Key("ImportDataSource") 1020 if err := awsRestjson1_serializeDocumentImportDataSource(v.ImportDataSource, ok); err != nil { 1021 return err 1022 } 1023 } 1024 1025 if v.ImportDestination != nil { 1026 ok := object.Key("ImportDestination") 1027 if err := awsRestjson1_serializeDocumentImportDestination(v.ImportDestination, ok); err != nil { 1028 return err 1029 } 1030 } 1031 1032 return nil 1033} 1034 1035type awsRestjson1_serializeOpDeleteConfigurationSet struct { 1036} 1037 1038func (*awsRestjson1_serializeOpDeleteConfigurationSet) ID() string { 1039 return "OperationSerializer" 1040} 1041 1042func (m *awsRestjson1_serializeOpDeleteConfigurationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1043 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1044) { 1045 request, ok := in.Request.(*smithyhttp.Request) 1046 if !ok { 1047 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1048 } 1049 1050 input, ok := in.Parameters.(*DeleteConfigurationSetInput) 1051 _ = input 1052 if !ok { 1053 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1054 } 1055 1056 opPath, opQuery := httpbinding.SplitURI("/v2/email/configuration-sets/{ConfigurationSetName}") 1057 request.URL.Path = opPath 1058 if len(request.URL.RawQuery) > 0 { 1059 request.URL.RawQuery = "&" + opQuery 1060 } else { 1061 request.URL.RawQuery = opQuery 1062 } 1063 1064 request.Method = "DELETE" 1065 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1066 if err != nil { 1067 return out, metadata, &smithy.SerializationError{Err: err} 1068 } 1069 1070 if err := awsRestjson1_serializeOpHttpBindingsDeleteConfigurationSetInput(input, restEncoder); err != nil { 1071 return out, metadata, &smithy.SerializationError{Err: err} 1072 } 1073 1074 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1075 return out, metadata, &smithy.SerializationError{Err: err} 1076 } 1077 in.Request = request 1078 1079 return next.HandleSerialize(ctx, in) 1080} 1081func awsRestjson1_serializeOpHttpBindingsDeleteConfigurationSetInput(v *DeleteConfigurationSetInput, encoder *httpbinding.Encoder) error { 1082 if v == nil { 1083 return fmt.Errorf("unsupported serialization of nil %T", v) 1084 } 1085 1086 if v.ConfigurationSetName == nil || len(*v.ConfigurationSetName) == 0 { 1087 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationSetName must not be empty")} 1088 } 1089 if v.ConfigurationSetName != nil { 1090 if err := encoder.SetURI("ConfigurationSetName").String(*v.ConfigurationSetName); err != nil { 1091 return err 1092 } 1093 } 1094 1095 return nil 1096} 1097 1098type awsRestjson1_serializeOpDeleteConfigurationSetEventDestination struct { 1099} 1100 1101func (*awsRestjson1_serializeOpDeleteConfigurationSetEventDestination) ID() string { 1102 return "OperationSerializer" 1103} 1104 1105func (m *awsRestjson1_serializeOpDeleteConfigurationSetEventDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1106 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1107) { 1108 request, ok := in.Request.(*smithyhttp.Request) 1109 if !ok { 1110 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1111 } 1112 1113 input, ok := in.Parameters.(*DeleteConfigurationSetEventDestinationInput) 1114 _ = input 1115 if !ok { 1116 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1117 } 1118 1119 opPath, opQuery := httpbinding.SplitURI("/v2/email/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}") 1120 request.URL.Path = opPath 1121 if len(request.URL.RawQuery) > 0 { 1122 request.URL.RawQuery = "&" + opQuery 1123 } else { 1124 request.URL.RawQuery = opQuery 1125 } 1126 1127 request.Method = "DELETE" 1128 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1129 if err != nil { 1130 return out, metadata, &smithy.SerializationError{Err: err} 1131 } 1132 1133 if err := awsRestjson1_serializeOpHttpBindingsDeleteConfigurationSetEventDestinationInput(input, restEncoder); err != nil { 1134 return out, metadata, &smithy.SerializationError{Err: err} 1135 } 1136 1137 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1138 return out, metadata, &smithy.SerializationError{Err: err} 1139 } 1140 in.Request = request 1141 1142 return next.HandleSerialize(ctx, in) 1143} 1144func awsRestjson1_serializeOpHttpBindingsDeleteConfigurationSetEventDestinationInput(v *DeleteConfigurationSetEventDestinationInput, encoder *httpbinding.Encoder) error { 1145 if v == nil { 1146 return fmt.Errorf("unsupported serialization of nil %T", v) 1147 } 1148 1149 if v.ConfigurationSetName == nil || len(*v.ConfigurationSetName) == 0 { 1150 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationSetName must not be empty")} 1151 } 1152 if v.ConfigurationSetName != nil { 1153 if err := encoder.SetURI("ConfigurationSetName").String(*v.ConfigurationSetName); err != nil { 1154 return err 1155 } 1156 } 1157 1158 if v.EventDestinationName == nil || len(*v.EventDestinationName) == 0 { 1159 return &smithy.SerializationError{Err: fmt.Errorf("input member EventDestinationName must not be empty")} 1160 } 1161 if v.EventDestinationName != nil { 1162 if err := encoder.SetURI("EventDestinationName").String(*v.EventDestinationName); err != nil { 1163 return err 1164 } 1165 } 1166 1167 return nil 1168} 1169 1170type awsRestjson1_serializeOpDeleteContact struct { 1171} 1172 1173func (*awsRestjson1_serializeOpDeleteContact) ID() string { 1174 return "OperationSerializer" 1175} 1176 1177func (m *awsRestjson1_serializeOpDeleteContact) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1178 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1179) { 1180 request, ok := in.Request.(*smithyhttp.Request) 1181 if !ok { 1182 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1183 } 1184 1185 input, ok := in.Parameters.(*DeleteContactInput) 1186 _ = input 1187 if !ok { 1188 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1189 } 1190 1191 opPath, opQuery := httpbinding.SplitURI("/v2/email/contact-lists/{ContactListName}/contacts/{EmailAddress}") 1192 request.URL.Path = opPath 1193 if len(request.URL.RawQuery) > 0 { 1194 request.URL.RawQuery = "&" + opQuery 1195 } else { 1196 request.URL.RawQuery = opQuery 1197 } 1198 1199 request.Method = "DELETE" 1200 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1201 if err != nil { 1202 return out, metadata, &smithy.SerializationError{Err: err} 1203 } 1204 1205 if err := awsRestjson1_serializeOpHttpBindingsDeleteContactInput(input, restEncoder); err != nil { 1206 return out, metadata, &smithy.SerializationError{Err: err} 1207 } 1208 1209 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1210 return out, metadata, &smithy.SerializationError{Err: err} 1211 } 1212 in.Request = request 1213 1214 return next.HandleSerialize(ctx, in) 1215} 1216func awsRestjson1_serializeOpHttpBindingsDeleteContactInput(v *DeleteContactInput, encoder *httpbinding.Encoder) error { 1217 if v == nil { 1218 return fmt.Errorf("unsupported serialization of nil %T", v) 1219 } 1220 1221 if v.ContactListName == nil || len(*v.ContactListName) == 0 { 1222 return &smithy.SerializationError{Err: fmt.Errorf("input member ContactListName must not be empty")} 1223 } 1224 if v.ContactListName != nil { 1225 if err := encoder.SetURI("ContactListName").String(*v.ContactListName); err != nil { 1226 return err 1227 } 1228 } 1229 1230 if v.EmailAddress == nil || len(*v.EmailAddress) == 0 { 1231 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailAddress must not be empty")} 1232 } 1233 if v.EmailAddress != nil { 1234 if err := encoder.SetURI("EmailAddress").String(*v.EmailAddress); err != nil { 1235 return err 1236 } 1237 } 1238 1239 return nil 1240} 1241 1242type awsRestjson1_serializeOpDeleteContactList struct { 1243} 1244 1245func (*awsRestjson1_serializeOpDeleteContactList) ID() string { 1246 return "OperationSerializer" 1247} 1248 1249func (m *awsRestjson1_serializeOpDeleteContactList) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1250 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1251) { 1252 request, ok := in.Request.(*smithyhttp.Request) 1253 if !ok { 1254 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1255 } 1256 1257 input, ok := in.Parameters.(*DeleteContactListInput) 1258 _ = input 1259 if !ok { 1260 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1261 } 1262 1263 opPath, opQuery := httpbinding.SplitURI("/v2/email/contact-lists/{ContactListName}") 1264 request.URL.Path = opPath 1265 if len(request.URL.RawQuery) > 0 { 1266 request.URL.RawQuery = "&" + opQuery 1267 } else { 1268 request.URL.RawQuery = opQuery 1269 } 1270 1271 request.Method = "DELETE" 1272 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1273 if err != nil { 1274 return out, metadata, &smithy.SerializationError{Err: err} 1275 } 1276 1277 if err := awsRestjson1_serializeOpHttpBindingsDeleteContactListInput(input, restEncoder); err != nil { 1278 return out, metadata, &smithy.SerializationError{Err: err} 1279 } 1280 1281 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1282 return out, metadata, &smithy.SerializationError{Err: err} 1283 } 1284 in.Request = request 1285 1286 return next.HandleSerialize(ctx, in) 1287} 1288func awsRestjson1_serializeOpHttpBindingsDeleteContactListInput(v *DeleteContactListInput, encoder *httpbinding.Encoder) error { 1289 if v == nil { 1290 return fmt.Errorf("unsupported serialization of nil %T", v) 1291 } 1292 1293 if v.ContactListName == nil || len(*v.ContactListName) == 0 { 1294 return &smithy.SerializationError{Err: fmt.Errorf("input member ContactListName must not be empty")} 1295 } 1296 if v.ContactListName != nil { 1297 if err := encoder.SetURI("ContactListName").String(*v.ContactListName); err != nil { 1298 return err 1299 } 1300 } 1301 1302 return nil 1303} 1304 1305type awsRestjson1_serializeOpDeleteCustomVerificationEmailTemplate struct { 1306} 1307 1308func (*awsRestjson1_serializeOpDeleteCustomVerificationEmailTemplate) ID() string { 1309 return "OperationSerializer" 1310} 1311 1312func (m *awsRestjson1_serializeOpDeleteCustomVerificationEmailTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1313 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1314) { 1315 request, ok := in.Request.(*smithyhttp.Request) 1316 if !ok { 1317 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1318 } 1319 1320 input, ok := in.Parameters.(*DeleteCustomVerificationEmailTemplateInput) 1321 _ = input 1322 if !ok { 1323 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1324 } 1325 1326 opPath, opQuery := httpbinding.SplitURI("/v2/email/custom-verification-email-templates/{TemplateName}") 1327 request.URL.Path = opPath 1328 if len(request.URL.RawQuery) > 0 { 1329 request.URL.RawQuery = "&" + opQuery 1330 } else { 1331 request.URL.RawQuery = opQuery 1332 } 1333 1334 request.Method = "DELETE" 1335 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1336 if err != nil { 1337 return out, metadata, &smithy.SerializationError{Err: err} 1338 } 1339 1340 if err := awsRestjson1_serializeOpHttpBindingsDeleteCustomVerificationEmailTemplateInput(input, restEncoder); err != nil { 1341 return out, metadata, &smithy.SerializationError{Err: err} 1342 } 1343 1344 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1345 return out, metadata, &smithy.SerializationError{Err: err} 1346 } 1347 in.Request = request 1348 1349 return next.HandleSerialize(ctx, in) 1350} 1351func awsRestjson1_serializeOpHttpBindingsDeleteCustomVerificationEmailTemplateInput(v *DeleteCustomVerificationEmailTemplateInput, encoder *httpbinding.Encoder) error { 1352 if v == nil { 1353 return fmt.Errorf("unsupported serialization of nil %T", v) 1354 } 1355 1356 if v.TemplateName == nil || len(*v.TemplateName) == 0 { 1357 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateName must not be empty")} 1358 } 1359 if v.TemplateName != nil { 1360 if err := encoder.SetURI("TemplateName").String(*v.TemplateName); err != nil { 1361 return err 1362 } 1363 } 1364 1365 return nil 1366} 1367 1368type awsRestjson1_serializeOpDeleteDedicatedIpPool struct { 1369} 1370 1371func (*awsRestjson1_serializeOpDeleteDedicatedIpPool) ID() string { 1372 return "OperationSerializer" 1373} 1374 1375func (m *awsRestjson1_serializeOpDeleteDedicatedIpPool) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1376 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1377) { 1378 request, ok := in.Request.(*smithyhttp.Request) 1379 if !ok { 1380 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1381 } 1382 1383 input, ok := in.Parameters.(*DeleteDedicatedIpPoolInput) 1384 _ = input 1385 if !ok { 1386 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1387 } 1388 1389 opPath, opQuery := httpbinding.SplitURI("/v2/email/dedicated-ip-pools/{PoolName}") 1390 request.URL.Path = opPath 1391 if len(request.URL.RawQuery) > 0 { 1392 request.URL.RawQuery = "&" + opQuery 1393 } else { 1394 request.URL.RawQuery = opQuery 1395 } 1396 1397 request.Method = "DELETE" 1398 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1399 if err != nil { 1400 return out, metadata, &smithy.SerializationError{Err: err} 1401 } 1402 1403 if err := awsRestjson1_serializeOpHttpBindingsDeleteDedicatedIpPoolInput(input, restEncoder); err != nil { 1404 return out, metadata, &smithy.SerializationError{Err: err} 1405 } 1406 1407 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1408 return out, metadata, &smithy.SerializationError{Err: err} 1409 } 1410 in.Request = request 1411 1412 return next.HandleSerialize(ctx, in) 1413} 1414func awsRestjson1_serializeOpHttpBindingsDeleteDedicatedIpPoolInput(v *DeleteDedicatedIpPoolInput, encoder *httpbinding.Encoder) error { 1415 if v == nil { 1416 return fmt.Errorf("unsupported serialization of nil %T", v) 1417 } 1418 1419 if v.PoolName == nil || len(*v.PoolName) == 0 { 1420 return &smithy.SerializationError{Err: fmt.Errorf("input member PoolName must not be empty")} 1421 } 1422 if v.PoolName != nil { 1423 if err := encoder.SetURI("PoolName").String(*v.PoolName); err != nil { 1424 return err 1425 } 1426 } 1427 1428 return nil 1429} 1430 1431type awsRestjson1_serializeOpDeleteEmailIdentity struct { 1432} 1433 1434func (*awsRestjson1_serializeOpDeleteEmailIdentity) ID() string { 1435 return "OperationSerializer" 1436} 1437 1438func (m *awsRestjson1_serializeOpDeleteEmailIdentity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1439 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1440) { 1441 request, ok := in.Request.(*smithyhttp.Request) 1442 if !ok { 1443 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1444 } 1445 1446 input, ok := in.Parameters.(*DeleteEmailIdentityInput) 1447 _ = input 1448 if !ok { 1449 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1450 } 1451 1452 opPath, opQuery := httpbinding.SplitURI("/v2/email/identities/{EmailIdentity}") 1453 request.URL.Path = opPath 1454 if len(request.URL.RawQuery) > 0 { 1455 request.URL.RawQuery = "&" + opQuery 1456 } else { 1457 request.URL.RawQuery = opQuery 1458 } 1459 1460 request.Method = "DELETE" 1461 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1462 if err != nil { 1463 return out, metadata, &smithy.SerializationError{Err: err} 1464 } 1465 1466 if err := awsRestjson1_serializeOpHttpBindingsDeleteEmailIdentityInput(input, restEncoder); err != nil { 1467 return out, metadata, &smithy.SerializationError{Err: err} 1468 } 1469 1470 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1471 return out, metadata, &smithy.SerializationError{Err: err} 1472 } 1473 in.Request = request 1474 1475 return next.HandleSerialize(ctx, in) 1476} 1477func awsRestjson1_serializeOpHttpBindingsDeleteEmailIdentityInput(v *DeleteEmailIdentityInput, encoder *httpbinding.Encoder) error { 1478 if v == nil { 1479 return fmt.Errorf("unsupported serialization of nil %T", v) 1480 } 1481 1482 if v.EmailIdentity == nil || len(*v.EmailIdentity) == 0 { 1483 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailIdentity must not be empty")} 1484 } 1485 if v.EmailIdentity != nil { 1486 if err := encoder.SetURI("EmailIdentity").String(*v.EmailIdentity); err != nil { 1487 return err 1488 } 1489 } 1490 1491 return nil 1492} 1493 1494type awsRestjson1_serializeOpDeleteEmailIdentityPolicy struct { 1495} 1496 1497func (*awsRestjson1_serializeOpDeleteEmailIdentityPolicy) ID() string { 1498 return "OperationSerializer" 1499} 1500 1501func (m *awsRestjson1_serializeOpDeleteEmailIdentityPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1502 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1503) { 1504 request, ok := in.Request.(*smithyhttp.Request) 1505 if !ok { 1506 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1507 } 1508 1509 input, ok := in.Parameters.(*DeleteEmailIdentityPolicyInput) 1510 _ = input 1511 if !ok { 1512 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1513 } 1514 1515 opPath, opQuery := httpbinding.SplitURI("/v2/email/identities/{EmailIdentity}/policies/{PolicyName}") 1516 request.URL.Path = opPath 1517 if len(request.URL.RawQuery) > 0 { 1518 request.URL.RawQuery = "&" + opQuery 1519 } else { 1520 request.URL.RawQuery = opQuery 1521 } 1522 1523 request.Method = "DELETE" 1524 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1525 if err != nil { 1526 return out, metadata, &smithy.SerializationError{Err: err} 1527 } 1528 1529 if err := awsRestjson1_serializeOpHttpBindingsDeleteEmailIdentityPolicyInput(input, restEncoder); err != nil { 1530 return out, metadata, &smithy.SerializationError{Err: err} 1531 } 1532 1533 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1534 return out, metadata, &smithy.SerializationError{Err: err} 1535 } 1536 in.Request = request 1537 1538 return next.HandleSerialize(ctx, in) 1539} 1540func awsRestjson1_serializeOpHttpBindingsDeleteEmailIdentityPolicyInput(v *DeleteEmailIdentityPolicyInput, encoder *httpbinding.Encoder) error { 1541 if v == nil { 1542 return fmt.Errorf("unsupported serialization of nil %T", v) 1543 } 1544 1545 if v.EmailIdentity == nil || len(*v.EmailIdentity) == 0 { 1546 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailIdentity must not be empty")} 1547 } 1548 if v.EmailIdentity != nil { 1549 if err := encoder.SetURI("EmailIdentity").String(*v.EmailIdentity); err != nil { 1550 return err 1551 } 1552 } 1553 1554 if v.PolicyName == nil || len(*v.PolicyName) == 0 { 1555 return &smithy.SerializationError{Err: fmt.Errorf("input member PolicyName must not be empty")} 1556 } 1557 if v.PolicyName != nil { 1558 if err := encoder.SetURI("PolicyName").String(*v.PolicyName); err != nil { 1559 return err 1560 } 1561 } 1562 1563 return nil 1564} 1565 1566type awsRestjson1_serializeOpDeleteEmailTemplate struct { 1567} 1568 1569func (*awsRestjson1_serializeOpDeleteEmailTemplate) ID() string { 1570 return "OperationSerializer" 1571} 1572 1573func (m *awsRestjson1_serializeOpDeleteEmailTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1574 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1575) { 1576 request, ok := in.Request.(*smithyhttp.Request) 1577 if !ok { 1578 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1579 } 1580 1581 input, ok := in.Parameters.(*DeleteEmailTemplateInput) 1582 _ = input 1583 if !ok { 1584 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1585 } 1586 1587 opPath, opQuery := httpbinding.SplitURI("/v2/email/templates/{TemplateName}") 1588 request.URL.Path = opPath 1589 if len(request.URL.RawQuery) > 0 { 1590 request.URL.RawQuery = "&" + opQuery 1591 } else { 1592 request.URL.RawQuery = opQuery 1593 } 1594 1595 request.Method = "DELETE" 1596 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1597 if err != nil { 1598 return out, metadata, &smithy.SerializationError{Err: err} 1599 } 1600 1601 if err := awsRestjson1_serializeOpHttpBindingsDeleteEmailTemplateInput(input, restEncoder); err != nil { 1602 return out, metadata, &smithy.SerializationError{Err: err} 1603 } 1604 1605 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1606 return out, metadata, &smithy.SerializationError{Err: err} 1607 } 1608 in.Request = request 1609 1610 return next.HandleSerialize(ctx, in) 1611} 1612func awsRestjson1_serializeOpHttpBindingsDeleteEmailTemplateInput(v *DeleteEmailTemplateInput, encoder *httpbinding.Encoder) error { 1613 if v == nil { 1614 return fmt.Errorf("unsupported serialization of nil %T", v) 1615 } 1616 1617 if v.TemplateName == nil || len(*v.TemplateName) == 0 { 1618 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateName must not be empty")} 1619 } 1620 if v.TemplateName != nil { 1621 if err := encoder.SetURI("TemplateName").String(*v.TemplateName); err != nil { 1622 return err 1623 } 1624 } 1625 1626 return nil 1627} 1628 1629type awsRestjson1_serializeOpDeleteSuppressedDestination struct { 1630} 1631 1632func (*awsRestjson1_serializeOpDeleteSuppressedDestination) ID() string { 1633 return "OperationSerializer" 1634} 1635 1636func (m *awsRestjson1_serializeOpDeleteSuppressedDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1637 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1638) { 1639 request, ok := in.Request.(*smithyhttp.Request) 1640 if !ok { 1641 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1642 } 1643 1644 input, ok := in.Parameters.(*DeleteSuppressedDestinationInput) 1645 _ = input 1646 if !ok { 1647 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1648 } 1649 1650 opPath, opQuery := httpbinding.SplitURI("/v2/email/suppression/addresses/{EmailAddress}") 1651 request.URL.Path = opPath 1652 if len(request.URL.RawQuery) > 0 { 1653 request.URL.RawQuery = "&" + opQuery 1654 } else { 1655 request.URL.RawQuery = opQuery 1656 } 1657 1658 request.Method = "DELETE" 1659 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1660 if err != nil { 1661 return out, metadata, &smithy.SerializationError{Err: err} 1662 } 1663 1664 if err := awsRestjson1_serializeOpHttpBindingsDeleteSuppressedDestinationInput(input, restEncoder); err != nil { 1665 return out, metadata, &smithy.SerializationError{Err: err} 1666 } 1667 1668 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1669 return out, metadata, &smithy.SerializationError{Err: err} 1670 } 1671 in.Request = request 1672 1673 return next.HandleSerialize(ctx, in) 1674} 1675func awsRestjson1_serializeOpHttpBindingsDeleteSuppressedDestinationInput(v *DeleteSuppressedDestinationInput, encoder *httpbinding.Encoder) error { 1676 if v == nil { 1677 return fmt.Errorf("unsupported serialization of nil %T", v) 1678 } 1679 1680 if v.EmailAddress == nil || len(*v.EmailAddress) == 0 { 1681 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailAddress must not be empty")} 1682 } 1683 if v.EmailAddress != nil { 1684 if err := encoder.SetURI("EmailAddress").String(*v.EmailAddress); err != nil { 1685 return err 1686 } 1687 } 1688 1689 return nil 1690} 1691 1692type awsRestjson1_serializeOpGetAccount struct { 1693} 1694 1695func (*awsRestjson1_serializeOpGetAccount) ID() string { 1696 return "OperationSerializer" 1697} 1698 1699func (m *awsRestjson1_serializeOpGetAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1700 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1701) { 1702 request, ok := in.Request.(*smithyhttp.Request) 1703 if !ok { 1704 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1705 } 1706 1707 input, ok := in.Parameters.(*GetAccountInput) 1708 _ = input 1709 if !ok { 1710 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1711 } 1712 1713 opPath, opQuery := httpbinding.SplitURI("/v2/email/account") 1714 request.URL.Path = opPath 1715 if len(request.URL.RawQuery) > 0 { 1716 request.URL.RawQuery = "&" + opQuery 1717 } else { 1718 request.URL.RawQuery = opQuery 1719 } 1720 1721 request.Method = "GET" 1722 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1723 if err != nil { 1724 return out, metadata, &smithy.SerializationError{Err: err} 1725 } 1726 1727 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1728 return out, metadata, &smithy.SerializationError{Err: err} 1729 } 1730 in.Request = request 1731 1732 return next.HandleSerialize(ctx, in) 1733} 1734func awsRestjson1_serializeOpHttpBindingsGetAccountInput(v *GetAccountInput, encoder *httpbinding.Encoder) error { 1735 if v == nil { 1736 return fmt.Errorf("unsupported serialization of nil %T", v) 1737 } 1738 1739 return nil 1740} 1741 1742type awsRestjson1_serializeOpGetBlacklistReports struct { 1743} 1744 1745func (*awsRestjson1_serializeOpGetBlacklistReports) ID() string { 1746 return "OperationSerializer" 1747} 1748 1749func (m *awsRestjson1_serializeOpGetBlacklistReports) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1750 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1751) { 1752 request, ok := in.Request.(*smithyhttp.Request) 1753 if !ok { 1754 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1755 } 1756 1757 input, ok := in.Parameters.(*GetBlacklistReportsInput) 1758 _ = input 1759 if !ok { 1760 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1761 } 1762 1763 opPath, opQuery := httpbinding.SplitURI("/v2/email/deliverability-dashboard/blacklist-report") 1764 request.URL.Path = opPath 1765 if len(request.URL.RawQuery) > 0 { 1766 request.URL.RawQuery = "&" + opQuery 1767 } else { 1768 request.URL.RawQuery = opQuery 1769 } 1770 1771 request.Method = "GET" 1772 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1773 if err != nil { 1774 return out, metadata, &smithy.SerializationError{Err: err} 1775 } 1776 1777 if err := awsRestjson1_serializeOpHttpBindingsGetBlacklistReportsInput(input, restEncoder); err != nil { 1778 return out, metadata, &smithy.SerializationError{Err: err} 1779 } 1780 1781 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1782 return out, metadata, &smithy.SerializationError{Err: err} 1783 } 1784 in.Request = request 1785 1786 return next.HandleSerialize(ctx, in) 1787} 1788func awsRestjson1_serializeOpHttpBindingsGetBlacklistReportsInput(v *GetBlacklistReportsInput, encoder *httpbinding.Encoder) error { 1789 if v == nil { 1790 return fmt.Errorf("unsupported serialization of nil %T", v) 1791 } 1792 1793 if v.BlacklistItemNames != nil { 1794 for i := range v.BlacklistItemNames { 1795 encoder.AddQuery("BlacklistItemNames").String(v.BlacklistItemNames[i]) 1796 } 1797 } 1798 1799 return nil 1800} 1801 1802type awsRestjson1_serializeOpGetConfigurationSet struct { 1803} 1804 1805func (*awsRestjson1_serializeOpGetConfigurationSet) ID() string { 1806 return "OperationSerializer" 1807} 1808 1809func (m *awsRestjson1_serializeOpGetConfigurationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1810 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1811) { 1812 request, ok := in.Request.(*smithyhttp.Request) 1813 if !ok { 1814 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1815 } 1816 1817 input, ok := in.Parameters.(*GetConfigurationSetInput) 1818 _ = input 1819 if !ok { 1820 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1821 } 1822 1823 opPath, opQuery := httpbinding.SplitURI("/v2/email/configuration-sets/{ConfigurationSetName}") 1824 request.URL.Path = opPath 1825 if len(request.URL.RawQuery) > 0 { 1826 request.URL.RawQuery = "&" + opQuery 1827 } else { 1828 request.URL.RawQuery = opQuery 1829 } 1830 1831 request.Method = "GET" 1832 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1833 if err != nil { 1834 return out, metadata, &smithy.SerializationError{Err: err} 1835 } 1836 1837 if err := awsRestjson1_serializeOpHttpBindingsGetConfigurationSetInput(input, restEncoder); err != nil { 1838 return out, metadata, &smithy.SerializationError{Err: err} 1839 } 1840 1841 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1842 return out, metadata, &smithy.SerializationError{Err: err} 1843 } 1844 in.Request = request 1845 1846 return next.HandleSerialize(ctx, in) 1847} 1848func awsRestjson1_serializeOpHttpBindingsGetConfigurationSetInput(v *GetConfigurationSetInput, encoder *httpbinding.Encoder) error { 1849 if v == nil { 1850 return fmt.Errorf("unsupported serialization of nil %T", v) 1851 } 1852 1853 if v.ConfigurationSetName == nil || len(*v.ConfigurationSetName) == 0 { 1854 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationSetName must not be empty")} 1855 } 1856 if v.ConfigurationSetName != nil { 1857 if err := encoder.SetURI("ConfigurationSetName").String(*v.ConfigurationSetName); err != nil { 1858 return err 1859 } 1860 } 1861 1862 return nil 1863} 1864 1865type awsRestjson1_serializeOpGetConfigurationSetEventDestinations struct { 1866} 1867 1868func (*awsRestjson1_serializeOpGetConfigurationSetEventDestinations) ID() string { 1869 return "OperationSerializer" 1870} 1871 1872func (m *awsRestjson1_serializeOpGetConfigurationSetEventDestinations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1873 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1874) { 1875 request, ok := in.Request.(*smithyhttp.Request) 1876 if !ok { 1877 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1878 } 1879 1880 input, ok := in.Parameters.(*GetConfigurationSetEventDestinationsInput) 1881 _ = input 1882 if !ok { 1883 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1884 } 1885 1886 opPath, opQuery := httpbinding.SplitURI("/v2/email/configuration-sets/{ConfigurationSetName}/event-destinations") 1887 request.URL.Path = opPath 1888 if len(request.URL.RawQuery) > 0 { 1889 request.URL.RawQuery = "&" + opQuery 1890 } else { 1891 request.URL.RawQuery = opQuery 1892 } 1893 1894 request.Method = "GET" 1895 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1896 if err != nil { 1897 return out, metadata, &smithy.SerializationError{Err: err} 1898 } 1899 1900 if err := awsRestjson1_serializeOpHttpBindingsGetConfigurationSetEventDestinationsInput(input, restEncoder); err != nil { 1901 return out, metadata, &smithy.SerializationError{Err: err} 1902 } 1903 1904 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1905 return out, metadata, &smithy.SerializationError{Err: err} 1906 } 1907 in.Request = request 1908 1909 return next.HandleSerialize(ctx, in) 1910} 1911func awsRestjson1_serializeOpHttpBindingsGetConfigurationSetEventDestinationsInput(v *GetConfigurationSetEventDestinationsInput, encoder *httpbinding.Encoder) error { 1912 if v == nil { 1913 return fmt.Errorf("unsupported serialization of nil %T", v) 1914 } 1915 1916 if v.ConfigurationSetName == nil || len(*v.ConfigurationSetName) == 0 { 1917 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationSetName must not be empty")} 1918 } 1919 if v.ConfigurationSetName != nil { 1920 if err := encoder.SetURI("ConfigurationSetName").String(*v.ConfigurationSetName); err != nil { 1921 return err 1922 } 1923 } 1924 1925 return nil 1926} 1927 1928type awsRestjson1_serializeOpGetContact struct { 1929} 1930 1931func (*awsRestjson1_serializeOpGetContact) ID() string { 1932 return "OperationSerializer" 1933} 1934 1935func (m *awsRestjson1_serializeOpGetContact) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1936 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1937) { 1938 request, ok := in.Request.(*smithyhttp.Request) 1939 if !ok { 1940 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1941 } 1942 1943 input, ok := in.Parameters.(*GetContactInput) 1944 _ = input 1945 if !ok { 1946 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1947 } 1948 1949 opPath, opQuery := httpbinding.SplitURI("/v2/email/contact-lists/{ContactListName}/contacts/{EmailAddress}") 1950 request.URL.Path = opPath 1951 if len(request.URL.RawQuery) > 0 { 1952 request.URL.RawQuery = "&" + opQuery 1953 } else { 1954 request.URL.RawQuery = opQuery 1955 } 1956 1957 request.Method = "GET" 1958 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1959 if err != nil { 1960 return out, metadata, &smithy.SerializationError{Err: err} 1961 } 1962 1963 if err := awsRestjson1_serializeOpHttpBindingsGetContactInput(input, restEncoder); err != nil { 1964 return out, metadata, &smithy.SerializationError{Err: err} 1965 } 1966 1967 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1968 return out, metadata, &smithy.SerializationError{Err: err} 1969 } 1970 in.Request = request 1971 1972 return next.HandleSerialize(ctx, in) 1973} 1974func awsRestjson1_serializeOpHttpBindingsGetContactInput(v *GetContactInput, encoder *httpbinding.Encoder) error { 1975 if v == nil { 1976 return fmt.Errorf("unsupported serialization of nil %T", v) 1977 } 1978 1979 if v.ContactListName == nil || len(*v.ContactListName) == 0 { 1980 return &smithy.SerializationError{Err: fmt.Errorf("input member ContactListName must not be empty")} 1981 } 1982 if v.ContactListName != nil { 1983 if err := encoder.SetURI("ContactListName").String(*v.ContactListName); err != nil { 1984 return err 1985 } 1986 } 1987 1988 if v.EmailAddress == nil || len(*v.EmailAddress) == 0 { 1989 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailAddress must not be empty")} 1990 } 1991 if v.EmailAddress != nil { 1992 if err := encoder.SetURI("EmailAddress").String(*v.EmailAddress); err != nil { 1993 return err 1994 } 1995 } 1996 1997 return nil 1998} 1999 2000type awsRestjson1_serializeOpGetContactList struct { 2001} 2002 2003func (*awsRestjson1_serializeOpGetContactList) ID() string { 2004 return "OperationSerializer" 2005} 2006 2007func (m *awsRestjson1_serializeOpGetContactList) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2008 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2009) { 2010 request, ok := in.Request.(*smithyhttp.Request) 2011 if !ok { 2012 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2013 } 2014 2015 input, ok := in.Parameters.(*GetContactListInput) 2016 _ = input 2017 if !ok { 2018 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2019 } 2020 2021 opPath, opQuery := httpbinding.SplitURI("/v2/email/contact-lists/{ContactListName}") 2022 request.URL.Path = opPath 2023 if len(request.URL.RawQuery) > 0 { 2024 request.URL.RawQuery = "&" + opQuery 2025 } else { 2026 request.URL.RawQuery = opQuery 2027 } 2028 2029 request.Method = "GET" 2030 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2031 if err != nil { 2032 return out, metadata, &smithy.SerializationError{Err: err} 2033 } 2034 2035 if err := awsRestjson1_serializeOpHttpBindingsGetContactListInput(input, restEncoder); err != nil { 2036 return out, metadata, &smithy.SerializationError{Err: err} 2037 } 2038 2039 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2040 return out, metadata, &smithy.SerializationError{Err: err} 2041 } 2042 in.Request = request 2043 2044 return next.HandleSerialize(ctx, in) 2045} 2046func awsRestjson1_serializeOpHttpBindingsGetContactListInput(v *GetContactListInput, encoder *httpbinding.Encoder) error { 2047 if v == nil { 2048 return fmt.Errorf("unsupported serialization of nil %T", v) 2049 } 2050 2051 if v.ContactListName == nil || len(*v.ContactListName) == 0 { 2052 return &smithy.SerializationError{Err: fmt.Errorf("input member ContactListName must not be empty")} 2053 } 2054 if v.ContactListName != nil { 2055 if err := encoder.SetURI("ContactListName").String(*v.ContactListName); err != nil { 2056 return err 2057 } 2058 } 2059 2060 return nil 2061} 2062 2063type awsRestjson1_serializeOpGetCustomVerificationEmailTemplate struct { 2064} 2065 2066func (*awsRestjson1_serializeOpGetCustomVerificationEmailTemplate) ID() string { 2067 return "OperationSerializer" 2068} 2069 2070func (m *awsRestjson1_serializeOpGetCustomVerificationEmailTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2071 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2072) { 2073 request, ok := in.Request.(*smithyhttp.Request) 2074 if !ok { 2075 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2076 } 2077 2078 input, ok := in.Parameters.(*GetCustomVerificationEmailTemplateInput) 2079 _ = input 2080 if !ok { 2081 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2082 } 2083 2084 opPath, opQuery := httpbinding.SplitURI("/v2/email/custom-verification-email-templates/{TemplateName}") 2085 request.URL.Path = opPath 2086 if len(request.URL.RawQuery) > 0 { 2087 request.URL.RawQuery = "&" + opQuery 2088 } else { 2089 request.URL.RawQuery = opQuery 2090 } 2091 2092 request.Method = "GET" 2093 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2094 if err != nil { 2095 return out, metadata, &smithy.SerializationError{Err: err} 2096 } 2097 2098 if err := awsRestjson1_serializeOpHttpBindingsGetCustomVerificationEmailTemplateInput(input, restEncoder); err != nil { 2099 return out, metadata, &smithy.SerializationError{Err: err} 2100 } 2101 2102 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2103 return out, metadata, &smithy.SerializationError{Err: err} 2104 } 2105 in.Request = request 2106 2107 return next.HandleSerialize(ctx, in) 2108} 2109func awsRestjson1_serializeOpHttpBindingsGetCustomVerificationEmailTemplateInput(v *GetCustomVerificationEmailTemplateInput, encoder *httpbinding.Encoder) error { 2110 if v == nil { 2111 return fmt.Errorf("unsupported serialization of nil %T", v) 2112 } 2113 2114 if v.TemplateName == nil || len(*v.TemplateName) == 0 { 2115 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateName must not be empty")} 2116 } 2117 if v.TemplateName != nil { 2118 if err := encoder.SetURI("TemplateName").String(*v.TemplateName); err != nil { 2119 return err 2120 } 2121 } 2122 2123 return nil 2124} 2125 2126type awsRestjson1_serializeOpGetDedicatedIp struct { 2127} 2128 2129func (*awsRestjson1_serializeOpGetDedicatedIp) ID() string { 2130 return "OperationSerializer" 2131} 2132 2133func (m *awsRestjson1_serializeOpGetDedicatedIp) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2134 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2135) { 2136 request, ok := in.Request.(*smithyhttp.Request) 2137 if !ok { 2138 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2139 } 2140 2141 input, ok := in.Parameters.(*GetDedicatedIpInput) 2142 _ = input 2143 if !ok { 2144 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2145 } 2146 2147 opPath, opQuery := httpbinding.SplitURI("/v2/email/dedicated-ips/{Ip}") 2148 request.URL.Path = opPath 2149 if len(request.URL.RawQuery) > 0 { 2150 request.URL.RawQuery = "&" + opQuery 2151 } else { 2152 request.URL.RawQuery = opQuery 2153 } 2154 2155 request.Method = "GET" 2156 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2157 if err != nil { 2158 return out, metadata, &smithy.SerializationError{Err: err} 2159 } 2160 2161 if err := awsRestjson1_serializeOpHttpBindingsGetDedicatedIpInput(input, restEncoder); err != nil { 2162 return out, metadata, &smithy.SerializationError{Err: err} 2163 } 2164 2165 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2166 return out, metadata, &smithy.SerializationError{Err: err} 2167 } 2168 in.Request = request 2169 2170 return next.HandleSerialize(ctx, in) 2171} 2172func awsRestjson1_serializeOpHttpBindingsGetDedicatedIpInput(v *GetDedicatedIpInput, encoder *httpbinding.Encoder) error { 2173 if v == nil { 2174 return fmt.Errorf("unsupported serialization of nil %T", v) 2175 } 2176 2177 if v.Ip == nil || len(*v.Ip) == 0 { 2178 return &smithy.SerializationError{Err: fmt.Errorf("input member Ip must not be empty")} 2179 } 2180 if v.Ip != nil { 2181 if err := encoder.SetURI("Ip").String(*v.Ip); err != nil { 2182 return err 2183 } 2184 } 2185 2186 return nil 2187} 2188 2189type awsRestjson1_serializeOpGetDedicatedIps struct { 2190} 2191 2192func (*awsRestjson1_serializeOpGetDedicatedIps) ID() string { 2193 return "OperationSerializer" 2194} 2195 2196func (m *awsRestjson1_serializeOpGetDedicatedIps) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2197 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2198) { 2199 request, ok := in.Request.(*smithyhttp.Request) 2200 if !ok { 2201 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2202 } 2203 2204 input, ok := in.Parameters.(*GetDedicatedIpsInput) 2205 _ = input 2206 if !ok { 2207 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2208 } 2209 2210 opPath, opQuery := httpbinding.SplitURI("/v2/email/dedicated-ips") 2211 request.URL.Path = opPath 2212 if len(request.URL.RawQuery) > 0 { 2213 request.URL.RawQuery = "&" + opQuery 2214 } else { 2215 request.URL.RawQuery = opQuery 2216 } 2217 2218 request.Method = "GET" 2219 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2220 if err != nil { 2221 return out, metadata, &smithy.SerializationError{Err: err} 2222 } 2223 2224 if err := awsRestjson1_serializeOpHttpBindingsGetDedicatedIpsInput(input, restEncoder); err != nil { 2225 return out, metadata, &smithy.SerializationError{Err: err} 2226 } 2227 2228 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2229 return out, metadata, &smithy.SerializationError{Err: err} 2230 } 2231 in.Request = request 2232 2233 return next.HandleSerialize(ctx, in) 2234} 2235func awsRestjson1_serializeOpHttpBindingsGetDedicatedIpsInput(v *GetDedicatedIpsInput, encoder *httpbinding.Encoder) error { 2236 if v == nil { 2237 return fmt.Errorf("unsupported serialization of nil %T", v) 2238 } 2239 2240 if v.NextToken != nil { 2241 encoder.SetQuery("NextToken").String(*v.NextToken) 2242 } 2243 2244 if v.PageSize != nil { 2245 encoder.SetQuery("PageSize").Integer(*v.PageSize) 2246 } 2247 2248 if v.PoolName != nil { 2249 encoder.SetQuery("PoolName").String(*v.PoolName) 2250 } 2251 2252 return nil 2253} 2254 2255type awsRestjson1_serializeOpGetDeliverabilityDashboardOptions struct { 2256} 2257 2258func (*awsRestjson1_serializeOpGetDeliverabilityDashboardOptions) ID() string { 2259 return "OperationSerializer" 2260} 2261 2262func (m *awsRestjson1_serializeOpGetDeliverabilityDashboardOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2263 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2264) { 2265 request, ok := in.Request.(*smithyhttp.Request) 2266 if !ok { 2267 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2268 } 2269 2270 input, ok := in.Parameters.(*GetDeliverabilityDashboardOptionsInput) 2271 _ = input 2272 if !ok { 2273 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2274 } 2275 2276 opPath, opQuery := httpbinding.SplitURI("/v2/email/deliverability-dashboard") 2277 request.URL.Path = opPath 2278 if len(request.URL.RawQuery) > 0 { 2279 request.URL.RawQuery = "&" + opQuery 2280 } else { 2281 request.URL.RawQuery = opQuery 2282 } 2283 2284 request.Method = "GET" 2285 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2286 if err != nil { 2287 return out, metadata, &smithy.SerializationError{Err: err} 2288 } 2289 2290 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2291 return out, metadata, &smithy.SerializationError{Err: err} 2292 } 2293 in.Request = request 2294 2295 return next.HandleSerialize(ctx, in) 2296} 2297func awsRestjson1_serializeOpHttpBindingsGetDeliverabilityDashboardOptionsInput(v *GetDeliverabilityDashboardOptionsInput, encoder *httpbinding.Encoder) error { 2298 if v == nil { 2299 return fmt.Errorf("unsupported serialization of nil %T", v) 2300 } 2301 2302 return nil 2303} 2304 2305type awsRestjson1_serializeOpGetDeliverabilityTestReport struct { 2306} 2307 2308func (*awsRestjson1_serializeOpGetDeliverabilityTestReport) ID() string { 2309 return "OperationSerializer" 2310} 2311 2312func (m *awsRestjson1_serializeOpGetDeliverabilityTestReport) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2313 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2314) { 2315 request, ok := in.Request.(*smithyhttp.Request) 2316 if !ok { 2317 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2318 } 2319 2320 input, ok := in.Parameters.(*GetDeliverabilityTestReportInput) 2321 _ = input 2322 if !ok { 2323 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2324 } 2325 2326 opPath, opQuery := httpbinding.SplitURI("/v2/email/deliverability-dashboard/test-reports/{ReportId}") 2327 request.URL.Path = opPath 2328 if len(request.URL.RawQuery) > 0 { 2329 request.URL.RawQuery = "&" + opQuery 2330 } else { 2331 request.URL.RawQuery = opQuery 2332 } 2333 2334 request.Method = "GET" 2335 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2336 if err != nil { 2337 return out, metadata, &smithy.SerializationError{Err: err} 2338 } 2339 2340 if err := awsRestjson1_serializeOpHttpBindingsGetDeliverabilityTestReportInput(input, restEncoder); err != nil { 2341 return out, metadata, &smithy.SerializationError{Err: err} 2342 } 2343 2344 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2345 return out, metadata, &smithy.SerializationError{Err: err} 2346 } 2347 in.Request = request 2348 2349 return next.HandleSerialize(ctx, in) 2350} 2351func awsRestjson1_serializeOpHttpBindingsGetDeliverabilityTestReportInput(v *GetDeliverabilityTestReportInput, encoder *httpbinding.Encoder) error { 2352 if v == nil { 2353 return fmt.Errorf("unsupported serialization of nil %T", v) 2354 } 2355 2356 if v.ReportId == nil || len(*v.ReportId) == 0 { 2357 return &smithy.SerializationError{Err: fmt.Errorf("input member ReportId must not be empty")} 2358 } 2359 if v.ReportId != nil { 2360 if err := encoder.SetURI("ReportId").String(*v.ReportId); err != nil { 2361 return err 2362 } 2363 } 2364 2365 return nil 2366} 2367 2368type awsRestjson1_serializeOpGetDomainDeliverabilityCampaign struct { 2369} 2370 2371func (*awsRestjson1_serializeOpGetDomainDeliverabilityCampaign) ID() string { 2372 return "OperationSerializer" 2373} 2374 2375func (m *awsRestjson1_serializeOpGetDomainDeliverabilityCampaign) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2376 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2377) { 2378 request, ok := in.Request.(*smithyhttp.Request) 2379 if !ok { 2380 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2381 } 2382 2383 input, ok := in.Parameters.(*GetDomainDeliverabilityCampaignInput) 2384 _ = input 2385 if !ok { 2386 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2387 } 2388 2389 opPath, opQuery := httpbinding.SplitURI("/v2/email/deliverability-dashboard/campaigns/{CampaignId}") 2390 request.URL.Path = opPath 2391 if len(request.URL.RawQuery) > 0 { 2392 request.URL.RawQuery = "&" + opQuery 2393 } else { 2394 request.URL.RawQuery = opQuery 2395 } 2396 2397 request.Method = "GET" 2398 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2399 if err != nil { 2400 return out, metadata, &smithy.SerializationError{Err: err} 2401 } 2402 2403 if err := awsRestjson1_serializeOpHttpBindingsGetDomainDeliverabilityCampaignInput(input, restEncoder); err != nil { 2404 return out, metadata, &smithy.SerializationError{Err: err} 2405 } 2406 2407 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2408 return out, metadata, &smithy.SerializationError{Err: err} 2409 } 2410 in.Request = request 2411 2412 return next.HandleSerialize(ctx, in) 2413} 2414func awsRestjson1_serializeOpHttpBindingsGetDomainDeliverabilityCampaignInput(v *GetDomainDeliverabilityCampaignInput, encoder *httpbinding.Encoder) error { 2415 if v == nil { 2416 return fmt.Errorf("unsupported serialization of nil %T", v) 2417 } 2418 2419 if v.CampaignId == nil || len(*v.CampaignId) == 0 { 2420 return &smithy.SerializationError{Err: fmt.Errorf("input member CampaignId must not be empty")} 2421 } 2422 if v.CampaignId != nil { 2423 if err := encoder.SetURI("CampaignId").String(*v.CampaignId); err != nil { 2424 return err 2425 } 2426 } 2427 2428 return nil 2429} 2430 2431type awsRestjson1_serializeOpGetDomainStatisticsReport struct { 2432} 2433 2434func (*awsRestjson1_serializeOpGetDomainStatisticsReport) ID() string { 2435 return "OperationSerializer" 2436} 2437 2438func (m *awsRestjson1_serializeOpGetDomainStatisticsReport) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2439 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2440) { 2441 request, ok := in.Request.(*smithyhttp.Request) 2442 if !ok { 2443 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2444 } 2445 2446 input, ok := in.Parameters.(*GetDomainStatisticsReportInput) 2447 _ = input 2448 if !ok { 2449 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2450 } 2451 2452 opPath, opQuery := httpbinding.SplitURI("/v2/email/deliverability-dashboard/statistics-report/{Domain}") 2453 request.URL.Path = opPath 2454 if len(request.URL.RawQuery) > 0 { 2455 request.URL.RawQuery = "&" + opQuery 2456 } else { 2457 request.URL.RawQuery = opQuery 2458 } 2459 2460 request.Method = "GET" 2461 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2462 if err != nil { 2463 return out, metadata, &smithy.SerializationError{Err: err} 2464 } 2465 2466 if err := awsRestjson1_serializeOpHttpBindingsGetDomainStatisticsReportInput(input, restEncoder); err != nil { 2467 return out, metadata, &smithy.SerializationError{Err: err} 2468 } 2469 2470 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2471 return out, metadata, &smithy.SerializationError{Err: err} 2472 } 2473 in.Request = request 2474 2475 return next.HandleSerialize(ctx, in) 2476} 2477func awsRestjson1_serializeOpHttpBindingsGetDomainStatisticsReportInput(v *GetDomainStatisticsReportInput, encoder *httpbinding.Encoder) error { 2478 if v == nil { 2479 return fmt.Errorf("unsupported serialization of nil %T", v) 2480 } 2481 2482 if v.Domain == nil || len(*v.Domain) == 0 { 2483 return &smithy.SerializationError{Err: fmt.Errorf("input member Domain must not be empty")} 2484 } 2485 if v.Domain != nil { 2486 if err := encoder.SetURI("Domain").String(*v.Domain); err != nil { 2487 return err 2488 } 2489 } 2490 2491 if v.EndDate != nil { 2492 encoder.SetQuery("EndDate").String(smithytime.FormatDateTime(*v.EndDate)) 2493 } 2494 2495 if v.StartDate != nil { 2496 encoder.SetQuery("StartDate").String(smithytime.FormatDateTime(*v.StartDate)) 2497 } 2498 2499 return nil 2500} 2501 2502type awsRestjson1_serializeOpGetEmailIdentity struct { 2503} 2504 2505func (*awsRestjson1_serializeOpGetEmailIdentity) ID() string { 2506 return "OperationSerializer" 2507} 2508 2509func (m *awsRestjson1_serializeOpGetEmailIdentity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2510 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2511) { 2512 request, ok := in.Request.(*smithyhttp.Request) 2513 if !ok { 2514 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2515 } 2516 2517 input, ok := in.Parameters.(*GetEmailIdentityInput) 2518 _ = input 2519 if !ok { 2520 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2521 } 2522 2523 opPath, opQuery := httpbinding.SplitURI("/v2/email/identities/{EmailIdentity}") 2524 request.URL.Path = opPath 2525 if len(request.URL.RawQuery) > 0 { 2526 request.URL.RawQuery = "&" + opQuery 2527 } else { 2528 request.URL.RawQuery = opQuery 2529 } 2530 2531 request.Method = "GET" 2532 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2533 if err != nil { 2534 return out, metadata, &smithy.SerializationError{Err: err} 2535 } 2536 2537 if err := awsRestjson1_serializeOpHttpBindingsGetEmailIdentityInput(input, restEncoder); err != nil { 2538 return out, metadata, &smithy.SerializationError{Err: err} 2539 } 2540 2541 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2542 return out, metadata, &smithy.SerializationError{Err: err} 2543 } 2544 in.Request = request 2545 2546 return next.HandleSerialize(ctx, in) 2547} 2548func awsRestjson1_serializeOpHttpBindingsGetEmailIdentityInput(v *GetEmailIdentityInput, encoder *httpbinding.Encoder) error { 2549 if v == nil { 2550 return fmt.Errorf("unsupported serialization of nil %T", v) 2551 } 2552 2553 if v.EmailIdentity == nil || len(*v.EmailIdentity) == 0 { 2554 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailIdentity must not be empty")} 2555 } 2556 if v.EmailIdentity != nil { 2557 if err := encoder.SetURI("EmailIdentity").String(*v.EmailIdentity); err != nil { 2558 return err 2559 } 2560 } 2561 2562 return nil 2563} 2564 2565type awsRestjson1_serializeOpGetEmailIdentityPolicies struct { 2566} 2567 2568func (*awsRestjson1_serializeOpGetEmailIdentityPolicies) ID() string { 2569 return "OperationSerializer" 2570} 2571 2572func (m *awsRestjson1_serializeOpGetEmailIdentityPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2573 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2574) { 2575 request, ok := in.Request.(*smithyhttp.Request) 2576 if !ok { 2577 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2578 } 2579 2580 input, ok := in.Parameters.(*GetEmailIdentityPoliciesInput) 2581 _ = input 2582 if !ok { 2583 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2584 } 2585 2586 opPath, opQuery := httpbinding.SplitURI("/v2/email/identities/{EmailIdentity}/policies") 2587 request.URL.Path = opPath 2588 if len(request.URL.RawQuery) > 0 { 2589 request.URL.RawQuery = "&" + opQuery 2590 } else { 2591 request.URL.RawQuery = opQuery 2592 } 2593 2594 request.Method = "GET" 2595 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2596 if err != nil { 2597 return out, metadata, &smithy.SerializationError{Err: err} 2598 } 2599 2600 if err := awsRestjson1_serializeOpHttpBindingsGetEmailIdentityPoliciesInput(input, restEncoder); err != nil { 2601 return out, metadata, &smithy.SerializationError{Err: err} 2602 } 2603 2604 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2605 return out, metadata, &smithy.SerializationError{Err: err} 2606 } 2607 in.Request = request 2608 2609 return next.HandleSerialize(ctx, in) 2610} 2611func awsRestjson1_serializeOpHttpBindingsGetEmailIdentityPoliciesInput(v *GetEmailIdentityPoliciesInput, encoder *httpbinding.Encoder) error { 2612 if v == nil { 2613 return fmt.Errorf("unsupported serialization of nil %T", v) 2614 } 2615 2616 if v.EmailIdentity == nil || len(*v.EmailIdentity) == 0 { 2617 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailIdentity must not be empty")} 2618 } 2619 if v.EmailIdentity != nil { 2620 if err := encoder.SetURI("EmailIdentity").String(*v.EmailIdentity); err != nil { 2621 return err 2622 } 2623 } 2624 2625 return nil 2626} 2627 2628type awsRestjson1_serializeOpGetEmailTemplate struct { 2629} 2630 2631func (*awsRestjson1_serializeOpGetEmailTemplate) ID() string { 2632 return "OperationSerializer" 2633} 2634 2635func (m *awsRestjson1_serializeOpGetEmailTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2636 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2637) { 2638 request, ok := in.Request.(*smithyhttp.Request) 2639 if !ok { 2640 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2641 } 2642 2643 input, ok := in.Parameters.(*GetEmailTemplateInput) 2644 _ = input 2645 if !ok { 2646 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2647 } 2648 2649 opPath, opQuery := httpbinding.SplitURI("/v2/email/templates/{TemplateName}") 2650 request.URL.Path = opPath 2651 if len(request.URL.RawQuery) > 0 { 2652 request.URL.RawQuery = "&" + opQuery 2653 } else { 2654 request.URL.RawQuery = opQuery 2655 } 2656 2657 request.Method = "GET" 2658 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2659 if err != nil { 2660 return out, metadata, &smithy.SerializationError{Err: err} 2661 } 2662 2663 if err := awsRestjson1_serializeOpHttpBindingsGetEmailTemplateInput(input, restEncoder); err != nil { 2664 return out, metadata, &smithy.SerializationError{Err: err} 2665 } 2666 2667 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2668 return out, metadata, &smithy.SerializationError{Err: err} 2669 } 2670 in.Request = request 2671 2672 return next.HandleSerialize(ctx, in) 2673} 2674func awsRestjson1_serializeOpHttpBindingsGetEmailTemplateInput(v *GetEmailTemplateInput, encoder *httpbinding.Encoder) error { 2675 if v == nil { 2676 return fmt.Errorf("unsupported serialization of nil %T", v) 2677 } 2678 2679 if v.TemplateName == nil || len(*v.TemplateName) == 0 { 2680 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateName must not be empty")} 2681 } 2682 if v.TemplateName != nil { 2683 if err := encoder.SetURI("TemplateName").String(*v.TemplateName); err != nil { 2684 return err 2685 } 2686 } 2687 2688 return nil 2689} 2690 2691type awsRestjson1_serializeOpGetImportJob struct { 2692} 2693 2694func (*awsRestjson1_serializeOpGetImportJob) ID() string { 2695 return "OperationSerializer" 2696} 2697 2698func (m *awsRestjson1_serializeOpGetImportJob) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2699 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2700) { 2701 request, ok := in.Request.(*smithyhttp.Request) 2702 if !ok { 2703 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2704 } 2705 2706 input, ok := in.Parameters.(*GetImportJobInput) 2707 _ = input 2708 if !ok { 2709 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2710 } 2711 2712 opPath, opQuery := httpbinding.SplitURI("/v2/email/import-jobs/{JobId}") 2713 request.URL.Path = opPath 2714 if len(request.URL.RawQuery) > 0 { 2715 request.URL.RawQuery = "&" + opQuery 2716 } else { 2717 request.URL.RawQuery = opQuery 2718 } 2719 2720 request.Method = "GET" 2721 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2722 if err != nil { 2723 return out, metadata, &smithy.SerializationError{Err: err} 2724 } 2725 2726 if err := awsRestjson1_serializeOpHttpBindingsGetImportJobInput(input, restEncoder); err != nil { 2727 return out, metadata, &smithy.SerializationError{Err: err} 2728 } 2729 2730 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2731 return out, metadata, &smithy.SerializationError{Err: err} 2732 } 2733 in.Request = request 2734 2735 return next.HandleSerialize(ctx, in) 2736} 2737func awsRestjson1_serializeOpHttpBindingsGetImportJobInput(v *GetImportJobInput, encoder *httpbinding.Encoder) error { 2738 if v == nil { 2739 return fmt.Errorf("unsupported serialization of nil %T", v) 2740 } 2741 2742 if v.JobId == nil || len(*v.JobId) == 0 { 2743 return &smithy.SerializationError{Err: fmt.Errorf("input member JobId must not be empty")} 2744 } 2745 if v.JobId != nil { 2746 if err := encoder.SetURI("JobId").String(*v.JobId); err != nil { 2747 return err 2748 } 2749 } 2750 2751 return nil 2752} 2753 2754type awsRestjson1_serializeOpGetSuppressedDestination struct { 2755} 2756 2757func (*awsRestjson1_serializeOpGetSuppressedDestination) ID() string { 2758 return "OperationSerializer" 2759} 2760 2761func (m *awsRestjson1_serializeOpGetSuppressedDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2762 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2763) { 2764 request, ok := in.Request.(*smithyhttp.Request) 2765 if !ok { 2766 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2767 } 2768 2769 input, ok := in.Parameters.(*GetSuppressedDestinationInput) 2770 _ = input 2771 if !ok { 2772 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2773 } 2774 2775 opPath, opQuery := httpbinding.SplitURI("/v2/email/suppression/addresses/{EmailAddress}") 2776 request.URL.Path = opPath 2777 if len(request.URL.RawQuery) > 0 { 2778 request.URL.RawQuery = "&" + opQuery 2779 } else { 2780 request.URL.RawQuery = opQuery 2781 } 2782 2783 request.Method = "GET" 2784 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2785 if err != nil { 2786 return out, metadata, &smithy.SerializationError{Err: err} 2787 } 2788 2789 if err := awsRestjson1_serializeOpHttpBindingsGetSuppressedDestinationInput(input, restEncoder); err != nil { 2790 return out, metadata, &smithy.SerializationError{Err: err} 2791 } 2792 2793 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2794 return out, metadata, &smithy.SerializationError{Err: err} 2795 } 2796 in.Request = request 2797 2798 return next.HandleSerialize(ctx, in) 2799} 2800func awsRestjson1_serializeOpHttpBindingsGetSuppressedDestinationInput(v *GetSuppressedDestinationInput, encoder *httpbinding.Encoder) error { 2801 if v == nil { 2802 return fmt.Errorf("unsupported serialization of nil %T", v) 2803 } 2804 2805 if v.EmailAddress == nil || len(*v.EmailAddress) == 0 { 2806 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailAddress must not be empty")} 2807 } 2808 if v.EmailAddress != nil { 2809 if err := encoder.SetURI("EmailAddress").String(*v.EmailAddress); err != nil { 2810 return err 2811 } 2812 } 2813 2814 return nil 2815} 2816 2817type awsRestjson1_serializeOpListConfigurationSets struct { 2818} 2819 2820func (*awsRestjson1_serializeOpListConfigurationSets) ID() string { 2821 return "OperationSerializer" 2822} 2823 2824func (m *awsRestjson1_serializeOpListConfigurationSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2825 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2826) { 2827 request, ok := in.Request.(*smithyhttp.Request) 2828 if !ok { 2829 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2830 } 2831 2832 input, ok := in.Parameters.(*ListConfigurationSetsInput) 2833 _ = input 2834 if !ok { 2835 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2836 } 2837 2838 opPath, opQuery := httpbinding.SplitURI("/v2/email/configuration-sets") 2839 request.URL.Path = opPath 2840 if len(request.URL.RawQuery) > 0 { 2841 request.URL.RawQuery = "&" + opQuery 2842 } else { 2843 request.URL.RawQuery = opQuery 2844 } 2845 2846 request.Method = "GET" 2847 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2848 if err != nil { 2849 return out, metadata, &smithy.SerializationError{Err: err} 2850 } 2851 2852 if err := awsRestjson1_serializeOpHttpBindingsListConfigurationSetsInput(input, restEncoder); err != nil { 2853 return out, metadata, &smithy.SerializationError{Err: err} 2854 } 2855 2856 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2857 return out, metadata, &smithy.SerializationError{Err: err} 2858 } 2859 in.Request = request 2860 2861 return next.HandleSerialize(ctx, in) 2862} 2863func awsRestjson1_serializeOpHttpBindingsListConfigurationSetsInput(v *ListConfigurationSetsInput, encoder *httpbinding.Encoder) error { 2864 if v == nil { 2865 return fmt.Errorf("unsupported serialization of nil %T", v) 2866 } 2867 2868 if v.NextToken != nil { 2869 encoder.SetQuery("NextToken").String(*v.NextToken) 2870 } 2871 2872 if v.PageSize != nil { 2873 encoder.SetQuery("PageSize").Integer(*v.PageSize) 2874 } 2875 2876 return nil 2877} 2878 2879type awsRestjson1_serializeOpListContactLists struct { 2880} 2881 2882func (*awsRestjson1_serializeOpListContactLists) ID() string { 2883 return "OperationSerializer" 2884} 2885 2886func (m *awsRestjson1_serializeOpListContactLists) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2887 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2888) { 2889 request, ok := in.Request.(*smithyhttp.Request) 2890 if !ok { 2891 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2892 } 2893 2894 input, ok := in.Parameters.(*ListContactListsInput) 2895 _ = input 2896 if !ok { 2897 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2898 } 2899 2900 opPath, opQuery := httpbinding.SplitURI("/v2/email/contact-lists") 2901 request.URL.Path = opPath 2902 if len(request.URL.RawQuery) > 0 { 2903 request.URL.RawQuery = "&" + opQuery 2904 } else { 2905 request.URL.RawQuery = opQuery 2906 } 2907 2908 request.Method = "GET" 2909 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2910 if err != nil { 2911 return out, metadata, &smithy.SerializationError{Err: err} 2912 } 2913 2914 if err := awsRestjson1_serializeOpHttpBindingsListContactListsInput(input, restEncoder); err != nil { 2915 return out, metadata, &smithy.SerializationError{Err: err} 2916 } 2917 2918 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2919 return out, metadata, &smithy.SerializationError{Err: err} 2920 } 2921 in.Request = request 2922 2923 return next.HandleSerialize(ctx, in) 2924} 2925func awsRestjson1_serializeOpHttpBindingsListContactListsInput(v *ListContactListsInput, encoder *httpbinding.Encoder) error { 2926 if v == nil { 2927 return fmt.Errorf("unsupported serialization of nil %T", v) 2928 } 2929 2930 if v.NextToken != nil { 2931 encoder.SetQuery("NextToken").String(*v.NextToken) 2932 } 2933 2934 if v.PageSize != nil { 2935 encoder.SetQuery("PageSize").Integer(*v.PageSize) 2936 } 2937 2938 return nil 2939} 2940 2941type awsRestjson1_serializeOpListContacts struct { 2942} 2943 2944func (*awsRestjson1_serializeOpListContacts) ID() string { 2945 return "OperationSerializer" 2946} 2947 2948func (m *awsRestjson1_serializeOpListContacts) 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.(*ListContactsInput) 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("/v2/email/contact-lists/{ContactListName}/contacts") 2963 request.URL.Path = opPath 2964 if len(request.URL.RawQuery) > 0 { 2965 request.URL.RawQuery = "&" + opQuery 2966 } else { 2967 request.URL.RawQuery = opQuery 2968 } 2969 2970 request.Method = "GET" 2971 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2972 if err != nil { 2973 return out, metadata, &smithy.SerializationError{Err: err} 2974 } 2975 2976 if err := awsRestjson1_serializeOpHttpBindingsListContactsInput(input, restEncoder); err != nil { 2977 return out, metadata, &smithy.SerializationError{Err: err} 2978 } 2979 2980 restEncoder.SetHeader("Content-Type").String("application/json") 2981 2982 jsonEncoder := smithyjson.NewEncoder() 2983 if err := awsRestjson1_serializeOpDocumentListContactsInput(input, jsonEncoder.Value); err != nil { 2984 return out, metadata, &smithy.SerializationError{Err: err} 2985 } 2986 2987 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2988 return out, metadata, &smithy.SerializationError{Err: err} 2989 } 2990 2991 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2992 return out, metadata, &smithy.SerializationError{Err: err} 2993 } 2994 in.Request = request 2995 2996 return next.HandleSerialize(ctx, in) 2997} 2998func awsRestjson1_serializeOpHttpBindingsListContactsInput(v *ListContactsInput, encoder *httpbinding.Encoder) error { 2999 if v == nil { 3000 return fmt.Errorf("unsupported serialization of nil %T", v) 3001 } 3002 3003 if v.ContactListName == nil || len(*v.ContactListName) == 0 { 3004 return &smithy.SerializationError{Err: fmt.Errorf("input member ContactListName must not be empty")} 3005 } 3006 if v.ContactListName != nil { 3007 if err := encoder.SetURI("ContactListName").String(*v.ContactListName); err != nil { 3008 return err 3009 } 3010 } 3011 3012 if v.NextToken != nil { 3013 encoder.SetQuery("NextToken").String(*v.NextToken) 3014 } 3015 3016 if v.PageSize != nil { 3017 encoder.SetQuery("PageSize").Integer(*v.PageSize) 3018 } 3019 3020 return nil 3021} 3022 3023func awsRestjson1_serializeOpDocumentListContactsInput(v *ListContactsInput, value smithyjson.Value) error { 3024 object := value.Object() 3025 defer object.Close() 3026 3027 if v.Filter != nil { 3028 ok := object.Key("Filter") 3029 if err := awsRestjson1_serializeDocumentListContactsFilter(v.Filter, ok); err != nil { 3030 return err 3031 } 3032 } 3033 3034 return nil 3035} 3036 3037type awsRestjson1_serializeOpListCustomVerificationEmailTemplates struct { 3038} 3039 3040func (*awsRestjson1_serializeOpListCustomVerificationEmailTemplates) ID() string { 3041 return "OperationSerializer" 3042} 3043 3044func (m *awsRestjson1_serializeOpListCustomVerificationEmailTemplates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3045 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3046) { 3047 request, ok := in.Request.(*smithyhttp.Request) 3048 if !ok { 3049 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3050 } 3051 3052 input, ok := in.Parameters.(*ListCustomVerificationEmailTemplatesInput) 3053 _ = input 3054 if !ok { 3055 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3056 } 3057 3058 opPath, opQuery := httpbinding.SplitURI("/v2/email/custom-verification-email-templates") 3059 request.URL.Path = opPath 3060 if len(request.URL.RawQuery) > 0 { 3061 request.URL.RawQuery = "&" + opQuery 3062 } else { 3063 request.URL.RawQuery = opQuery 3064 } 3065 3066 request.Method = "GET" 3067 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3068 if err != nil { 3069 return out, metadata, &smithy.SerializationError{Err: err} 3070 } 3071 3072 if err := awsRestjson1_serializeOpHttpBindingsListCustomVerificationEmailTemplatesInput(input, restEncoder); err != nil { 3073 return out, metadata, &smithy.SerializationError{Err: err} 3074 } 3075 3076 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3077 return out, metadata, &smithy.SerializationError{Err: err} 3078 } 3079 in.Request = request 3080 3081 return next.HandleSerialize(ctx, in) 3082} 3083func awsRestjson1_serializeOpHttpBindingsListCustomVerificationEmailTemplatesInput(v *ListCustomVerificationEmailTemplatesInput, encoder *httpbinding.Encoder) error { 3084 if v == nil { 3085 return fmt.Errorf("unsupported serialization of nil %T", v) 3086 } 3087 3088 if v.NextToken != nil { 3089 encoder.SetQuery("NextToken").String(*v.NextToken) 3090 } 3091 3092 if v.PageSize != nil { 3093 encoder.SetQuery("PageSize").Integer(*v.PageSize) 3094 } 3095 3096 return nil 3097} 3098 3099type awsRestjson1_serializeOpListDedicatedIpPools struct { 3100} 3101 3102func (*awsRestjson1_serializeOpListDedicatedIpPools) ID() string { 3103 return "OperationSerializer" 3104} 3105 3106func (m *awsRestjson1_serializeOpListDedicatedIpPools) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3107 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3108) { 3109 request, ok := in.Request.(*smithyhttp.Request) 3110 if !ok { 3111 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3112 } 3113 3114 input, ok := in.Parameters.(*ListDedicatedIpPoolsInput) 3115 _ = input 3116 if !ok { 3117 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3118 } 3119 3120 opPath, opQuery := httpbinding.SplitURI("/v2/email/dedicated-ip-pools") 3121 request.URL.Path = opPath 3122 if len(request.URL.RawQuery) > 0 { 3123 request.URL.RawQuery = "&" + opQuery 3124 } else { 3125 request.URL.RawQuery = opQuery 3126 } 3127 3128 request.Method = "GET" 3129 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3130 if err != nil { 3131 return out, metadata, &smithy.SerializationError{Err: err} 3132 } 3133 3134 if err := awsRestjson1_serializeOpHttpBindingsListDedicatedIpPoolsInput(input, restEncoder); err != nil { 3135 return out, metadata, &smithy.SerializationError{Err: err} 3136 } 3137 3138 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3139 return out, metadata, &smithy.SerializationError{Err: err} 3140 } 3141 in.Request = request 3142 3143 return next.HandleSerialize(ctx, in) 3144} 3145func awsRestjson1_serializeOpHttpBindingsListDedicatedIpPoolsInput(v *ListDedicatedIpPoolsInput, encoder *httpbinding.Encoder) error { 3146 if v == nil { 3147 return fmt.Errorf("unsupported serialization of nil %T", v) 3148 } 3149 3150 if v.NextToken != nil { 3151 encoder.SetQuery("NextToken").String(*v.NextToken) 3152 } 3153 3154 if v.PageSize != nil { 3155 encoder.SetQuery("PageSize").Integer(*v.PageSize) 3156 } 3157 3158 return nil 3159} 3160 3161type awsRestjson1_serializeOpListDeliverabilityTestReports struct { 3162} 3163 3164func (*awsRestjson1_serializeOpListDeliverabilityTestReports) ID() string { 3165 return "OperationSerializer" 3166} 3167 3168func (m *awsRestjson1_serializeOpListDeliverabilityTestReports) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3169 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3170) { 3171 request, ok := in.Request.(*smithyhttp.Request) 3172 if !ok { 3173 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3174 } 3175 3176 input, ok := in.Parameters.(*ListDeliverabilityTestReportsInput) 3177 _ = input 3178 if !ok { 3179 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3180 } 3181 3182 opPath, opQuery := httpbinding.SplitURI("/v2/email/deliverability-dashboard/test-reports") 3183 request.URL.Path = opPath 3184 if len(request.URL.RawQuery) > 0 { 3185 request.URL.RawQuery = "&" + opQuery 3186 } else { 3187 request.URL.RawQuery = opQuery 3188 } 3189 3190 request.Method = "GET" 3191 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3192 if err != nil { 3193 return out, metadata, &smithy.SerializationError{Err: err} 3194 } 3195 3196 if err := awsRestjson1_serializeOpHttpBindingsListDeliverabilityTestReportsInput(input, restEncoder); err != nil { 3197 return out, metadata, &smithy.SerializationError{Err: err} 3198 } 3199 3200 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3201 return out, metadata, &smithy.SerializationError{Err: err} 3202 } 3203 in.Request = request 3204 3205 return next.HandleSerialize(ctx, in) 3206} 3207func awsRestjson1_serializeOpHttpBindingsListDeliverabilityTestReportsInput(v *ListDeliverabilityTestReportsInput, encoder *httpbinding.Encoder) error { 3208 if v == nil { 3209 return fmt.Errorf("unsupported serialization of nil %T", v) 3210 } 3211 3212 if v.NextToken != nil { 3213 encoder.SetQuery("NextToken").String(*v.NextToken) 3214 } 3215 3216 if v.PageSize != nil { 3217 encoder.SetQuery("PageSize").Integer(*v.PageSize) 3218 } 3219 3220 return nil 3221} 3222 3223type awsRestjson1_serializeOpListDomainDeliverabilityCampaigns struct { 3224} 3225 3226func (*awsRestjson1_serializeOpListDomainDeliverabilityCampaigns) ID() string { 3227 return "OperationSerializer" 3228} 3229 3230func (m *awsRestjson1_serializeOpListDomainDeliverabilityCampaigns) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3231 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3232) { 3233 request, ok := in.Request.(*smithyhttp.Request) 3234 if !ok { 3235 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3236 } 3237 3238 input, ok := in.Parameters.(*ListDomainDeliverabilityCampaignsInput) 3239 _ = input 3240 if !ok { 3241 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3242 } 3243 3244 opPath, opQuery := httpbinding.SplitURI("/v2/email/deliverability-dashboard/domains/{SubscribedDomain}/campaigns") 3245 request.URL.Path = opPath 3246 if len(request.URL.RawQuery) > 0 { 3247 request.URL.RawQuery = "&" + opQuery 3248 } else { 3249 request.URL.RawQuery = opQuery 3250 } 3251 3252 request.Method = "GET" 3253 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3254 if err != nil { 3255 return out, metadata, &smithy.SerializationError{Err: err} 3256 } 3257 3258 if err := awsRestjson1_serializeOpHttpBindingsListDomainDeliverabilityCampaignsInput(input, restEncoder); err != nil { 3259 return out, metadata, &smithy.SerializationError{Err: err} 3260 } 3261 3262 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3263 return out, metadata, &smithy.SerializationError{Err: err} 3264 } 3265 in.Request = request 3266 3267 return next.HandleSerialize(ctx, in) 3268} 3269func awsRestjson1_serializeOpHttpBindingsListDomainDeliverabilityCampaignsInput(v *ListDomainDeliverabilityCampaignsInput, encoder *httpbinding.Encoder) error { 3270 if v == nil { 3271 return fmt.Errorf("unsupported serialization of nil %T", v) 3272 } 3273 3274 if v.EndDate != nil { 3275 encoder.SetQuery("EndDate").String(smithytime.FormatDateTime(*v.EndDate)) 3276 } 3277 3278 if v.NextToken != nil { 3279 encoder.SetQuery("NextToken").String(*v.NextToken) 3280 } 3281 3282 if v.PageSize != nil { 3283 encoder.SetQuery("PageSize").Integer(*v.PageSize) 3284 } 3285 3286 if v.StartDate != nil { 3287 encoder.SetQuery("StartDate").String(smithytime.FormatDateTime(*v.StartDate)) 3288 } 3289 3290 if v.SubscribedDomain == nil || len(*v.SubscribedDomain) == 0 { 3291 return &smithy.SerializationError{Err: fmt.Errorf("input member SubscribedDomain must not be empty")} 3292 } 3293 if v.SubscribedDomain != nil { 3294 if err := encoder.SetURI("SubscribedDomain").String(*v.SubscribedDomain); err != nil { 3295 return err 3296 } 3297 } 3298 3299 return nil 3300} 3301 3302type awsRestjson1_serializeOpListEmailIdentities struct { 3303} 3304 3305func (*awsRestjson1_serializeOpListEmailIdentities) ID() string { 3306 return "OperationSerializer" 3307} 3308 3309func (m *awsRestjson1_serializeOpListEmailIdentities) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3310 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3311) { 3312 request, ok := in.Request.(*smithyhttp.Request) 3313 if !ok { 3314 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3315 } 3316 3317 input, ok := in.Parameters.(*ListEmailIdentitiesInput) 3318 _ = input 3319 if !ok { 3320 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3321 } 3322 3323 opPath, opQuery := httpbinding.SplitURI("/v2/email/identities") 3324 request.URL.Path = opPath 3325 if len(request.URL.RawQuery) > 0 { 3326 request.URL.RawQuery = "&" + opQuery 3327 } else { 3328 request.URL.RawQuery = opQuery 3329 } 3330 3331 request.Method = "GET" 3332 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3333 if err != nil { 3334 return out, metadata, &smithy.SerializationError{Err: err} 3335 } 3336 3337 if err := awsRestjson1_serializeOpHttpBindingsListEmailIdentitiesInput(input, restEncoder); err != nil { 3338 return out, metadata, &smithy.SerializationError{Err: err} 3339 } 3340 3341 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3342 return out, metadata, &smithy.SerializationError{Err: err} 3343 } 3344 in.Request = request 3345 3346 return next.HandleSerialize(ctx, in) 3347} 3348func awsRestjson1_serializeOpHttpBindingsListEmailIdentitiesInput(v *ListEmailIdentitiesInput, encoder *httpbinding.Encoder) error { 3349 if v == nil { 3350 return fmt.Errorf("unsupported serialization of nil %T", v) 3351 } 3352 3353 if v.NextToken != nil { 3354 encoder.SetQuery("NextToken").String(*v.NextToken) 3355 } 3356 3357 if v.PageSize != nil { 3358 encoder.SetQuery("PageSize").Integer(*v.PageSize) 3359 } 3360 3361 return nil 3362} 3363 3364type awsRestjson1_serializeOpListEmailTemplates struct { 3365} 3366 3367func (*awsRestjson1_serializeOpListEmailTemplates) ID() string { 3368 return "OperationSerializer" 3369} 3370 3371func (m *awsRestjson1_serializeOpListEmailTemplates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3372 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3373) { 3374 request, ok := in.Request.(*smithyhttp.Request) 3375 if !ok { 3376 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3377 } 3378 3379 input, ok := in.Parameters.(*ListEmailTemplatesInput) 3380 _ = input 3381 if !ok { 3382 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3383 } 3384 3385 opPath, opQuery := httpbinding.SplitURI("/v2/email/templates") 3386 request.URL.Path = opPath 3387 if len(request.URL.RawQuery) > 0 { 3388 request.URL.RawQuery = "&" + opQuery 3389 } else { 3390 request.URL.RawQuery = opQuery 3391 } 3392 3393 request.Method = "GET" 3394 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3395 if err != nil { 3396 return out, metadata, &smithy.SerializationError{Err: err} 3397 } 3398 3399 if err := awsRestjson1_serializeOpHttpBindingsListEmailTemplatesInput(input, restEncoder); err != nil { 3400 return out, metadata, &smithy.SerializationError{Err: err} 3401 } 3402 3403 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3404 return out, metadata, &smithy.SerializationError{Err: err} 3405 } 3406 in.Request = request 3407 3408 return next.HandleSerialize(ctx, in) 3409} 3410func awsRestjson1_serializeOpHttpBindingsListEmailTemplatesInput(v *ListEmailTemplatesInput, encoder *httpbinding.Encoder) error { 3411 if v == nil { 3412 return fmt.Errorf("unsupported serialization of nil %T", v) 3413 } 3414 3415 if v.NextToken != nil { 3416 encoder.SetQuery("NextToken").String(*v.NextToken) 3417 } 3418 3419 if v.PageSize != nil { 3420 encoder.SetQuery("PageSize").Integer(*v.PageSize) 3421 } 3422 3423 return nil 3424} 3425 3426type awsRestjson1_serializeOpListImportJobs struct { 3427} 3428 3429func (*awsRestjson1_serializeOpListImportJobs) ID() string { 3430 return "OperationSerializer" 3431} 3432 3433func (m *awsRestjson1_serializeOpListImportJobs) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3434 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3435) { 3436 request, ok := in.Request.(*smithyhttp.Request) 3437 if !ok { 3438 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3439 } 3440 3441 input, ok := in.Parameters.(*ListImportJobsInput) 3442 _ = input 3443 if !ok { 3444 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3445 } 3446 3447 opPath, opQuery := httpbinding.SplitURI("/v2/email/import-jobs") 3448 request.URL.Path = opPath 3449 if len(request.URL.RawQuery) > 0 { 3450 request.URL.RawQuery = "&" + opQuery 3451 } else { 3452 request.URL.RawQuery = opQuery 3453 } 3454 3455 request.Method = "GET" 3456 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3457 if err != nil { 3458 return out, metadata, &smithy.SerializationError{Err: err} 3459 } 3460 3461 if err := awsRestjson1_serializeOpHttpBindingsListImportJobsInput(input, restEncoder); err != nil { 3462 return out, metadata, &smithy.SerializationError{Err: err} 3463 } 3464 3465 restEncoder.SetHeader("Content-Type").String("application/json") 3466 3467 jsonEncoder := smithyjson.NewEncoder() 3468 if err := awsRestjson1_serializeOpDocumentListImportJobsInput(input, jsonEncoder.Value); err != nil { 3469 return out, metadata, &smithy.SerializationError{Err: err} 3470 } 3471 3472 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3473 return out, metadata, &smithy.SerializationError{Err: err} 3474 } 3475 3476 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3477 return out, metadata, &smithy.SerializationError{Err: err} 3478 } 3479 in.Request = request 3480 3481 return next.HandleSerialize(ctx, in) 3482} 3483func awsRestjson1_serializeOpHttpBindingsListImportJobsInput(v *ListImportJobsInput, encoder *httpbinding.Encoder) error { 3484 if v == nil { 3485 return fmt.Errorf("unsupported serialization of nil %T", v) 3486 } 3487 3488 if v.NextToken != nil { 3489 encoder.SetQuery("NextToken").String(*v.NextToken) 3490 } 3491 3492 if v.PageSize != nil { 3493 encoder.SetQuery("PageSize").Integer(*v.PageSize) 3494 } 3495 3496 return nil 3497} 3498 3499func awsRestjson1_serializeOpDocumentListImportJobsInput(v *ListImportJobsInput, value smithyjson.Value) error { 3500 object := value.Object() 3501 defer object.Close() 3502 3503 if len(v.ImportDestinationType) > 0 { 3504 ok := object.Key("ImportDestinationType") 3505 ok.String(string(v.ImportDestinationType)) 3506 } 3507 3508 return nil 3509} 3510 3511type awsRestjson1_serializeOpListSuppressedDestinations struct { 3512} 3513 3514func (*awsRestjson1_serializeOpListSuppressedDestinations) ID() string { 3515 return "OperationSerializer" 3516} 3517 3518func (m *awsRestjson1_serializeOpListSuppressedDestinations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3519 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3520) { 3521 request, ok := in.Request.(*smithyhttp.Request) 3522 if !ok { 3523 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3524 } 3525 3526 input, ok := in.Parameters.(*ListSuppressedDestinationsInput) 3527 _ = input 3528 if !ok { 3529 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3530 } 3531 3532 opPath, opQuery := httpbinding.SplitURI("/v2/email/suppression/addresses") 3533 request.URL.Path = opPath 3534 if len(request.URL.RawQuery) > 0 { 3535 request.URL.RawQuery = "&" + opQuery 3536 } else { 3537 request.URL.RawQuery = opQuery 3538 } 3539 3540 request.Method = "GET" 3541 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3542 if err != nil { 3543 return out, metadata, &smithy.SerializationError{Err: err} 3544 } 3545 3546 if err := awsRestjson1_serializeOpHttpBindingsListSuppressedDestinationsInput(input, restEncoder); err != nil { 3547 return out, metadata, &smithy.SerializationError{Err: err} 3548 } 3549 3550 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3551 return out, metadata, &smithy.SerializationError{Err: err} 3552 } 3553 in.Request = request 3554 3555 return next.HandleSerialize(ctx, in) 3556} 3557func awsRestjson1_serializeOpHttpBindingsListSuppressedDestinationsInput(v *ListSuppressedDestinationsInput, encoder *httpbinding.Encoder) error { 3558 if v == nil { 3559 return fmt.Errorf("unsupported serialization of nil %T", v) 3560 } 3561 3562 if v.EndDate != nil { 3563 encoder.SetQuery("EndDate").String(smithytime.FormatDateTime(*v.EndDate)) 3564 } 3565 3566 if v.NextToken != nil { 3567 encoder.SetQuery("NextToken").String(*v.NextToken) 3568 } 3569 3570 if v.PageSize != nil { 3571 encoder.SetQuery("PageSize").Integer(*v.PageSize) 3572 } 3573 3574 if v.Reasons != nil { 3575 for i := range v.Reasons { 3576 encoder.AddQuery("Reason").String(string(v.Reasons[i])) 3577 } 3578 } 3579 3580 if v.StartDate != nil { 3581 encoder.SetQuery("StartDate").String(smithytime.FormatDateTime(*v.StartDate)) 3582 } 3583 3584 return nil 3585} 3586 3587type awsRestjson1_serializeOpListTagsForResource struct { 3588} 3589 3590func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 3591 return "OperationSerializer" 3592} 3593 3594func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3595 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3596) { 3597 request, ok := in.Request.(*smithyhttp.Request) 3598 if !ok { 3599 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3600 } 3601 3602 input, ok := in.Parameters.(*ListTagsForResourceInput) 3603 _ = input 3604 if !ok { 3605 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3606 } 3607 3608 opPath, opQuery := httpbinding.SplitURI("/v2/email/tags") 3609 request.URL.Path = opPath 3610 if len(request.URL.RawQuery) > 0 { 3611 request.URL.RawQuery = "&" + opQuery 3612 } else { 3613 request.URL.RawQuery = opQuery 3614 } 3615 3616 request.Method = "GET" 3617 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3618 if err != nil { 3619 return out, metadata, &smithy.SerializationError{Err: err} 3620 } 3621 3622 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 3623 return out, metadata, &smithy.SerializationError{Err: err} 3624 } 3625 3626 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3627 return out, metadata, &smithy.SerializationError{Err: err} 3628 } 3629 in.Request = request 3630 3631 return next.HandleSerialize(ctx, in) 3632} 3633func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 3634 if v == nil { 3635 return fmt.Errorf("unsupported serialization of nil %T", v) 3636 } 3637 3638 if v.ResourceArn != nil { 3639 encoder.SetQuery("ResourceArn").String(*v.ResourceArn) 3640 } 3641 3642 return nil 3643} 3644 3645type awsRestjson1_serializeOpPutAccountDedicatedIpWarmupAttributes struct { 3646} 3647 3648func (*awsRestjson1_serializeOpPutAccountDedicatedIpWarmupAttributes) ID() string { 3649 return "OperationSerializer" 3650} 3651 3652func (m *awsRestjson1_serializeOpPutAccountDedicatedIpWarmupAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3653 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3654) { 3655 request, ok := in.Request.(*smithyhttp.Request) 3656 if !ok { 3657 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3658 } 3659 3660 input, ok := in.Parameters.(*PutAccountDedicatedIpWarmupAttributesInput) 3661 _ = input 3662 if !ok { 3663 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3664 } 3665 3666 opPath, opQuery := httpbinding.SplitURI("/v2/email/account/dedicated-ips/warmup") 3667 request.URL.Path = opPath 3668 if len(request.URL.RawQuery) > 0 { 3669 request.URL.RawQuery = "&" + opQuery 3670 } else { 3671 request.URL.RawQuery = opQuery 3672 } 3673 3674 request.Method = "PUT" 3675 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3676 if err != nil { 3677 return out, metadata, &smithy.SerializationError{Err: err} 3678 } 3679 3680 restEncoder.SetHeader("Content-Type").String("application/json") 3681 3682 jsonEncoder := smithyjson.NewEncoder() 3683 if err := awsRestjson1_serializeOpDocumentPutAccountDedicatedIpWarmupAttributesInput(input, jsonEncoder.Value); err != nil { 3684 return out, metadata, &smithy.SerializationError{Err: err} 3685 } 3686 3687 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3688 return out, metadata, &smithy.SerializationError{Err: err} 3689 } 3690 3691 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3692 return out, metadata, &smithy.SerializationError{Err: err} 3693 } 3694 in.Request = request 3695 3696 return next.HandleSerialize(ctx, in) 3697} 3698func awsRestjson1_serializeOpHttpBindingsPutAccountDedicatedIpWarmupAttributesInput(v *PutAccountDedicatedIpWarmupAttributesInput, encoder *httpbinding.Encoder) error { 3699 if v == nil { 3700 return fmt.Errorf("unsupported serialization of nil %T", v) 3701 } 3702 3703 return nil 3704} 3705 3706func awsRestjson1_serializeOpDocumentPutAccountDedicatedIpWarmupAttributesInput(v *PutAccountDedicatedIpWarmupAttributesInput, value smithyjson.Value) error { 3707 object := value.Object() 3708 defer object.Close() 3709 3710 if v.AutoWarmupEnabled { 3711 ok := object.Key("AutoWarmupEnabled") 3712 ok.Boolean(v.AutoWarmupEnabled) 3713 } 3714 3715 return nil 3716} 3717 3718type awsRestjson1_serializeOpPutAccountDetails struct { 3719} 3720 3721func (*awsRestjson1_serializeOpPutAccountDetails) ID() string { 3722 return "OperationSerializer" 3723} 3724 3725func (m *awsRestjson1_serializeOpPutAccountDetails) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3726 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3727) { 3728 request, ok := in.Request.(*smithyhttp.Request) 3729 if !ok { 3730 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3731 } 3732 3733 input, ok := in.Parameters.(*PutAccountDetailsInput) 3734 _ = input 3735 if !ok { 3736 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3737 } 3738 3739 opPath, opQuery := httpbinding.SplitURI("/v2/email/account/details") 3740 request.URL.Path = opPath 3741 if len(request.URL.RawQuery) > 0 { 3742 request.URL.RawQuery = "&" + opQuery 3743 } else { 3744 request.URL.RawQuery = opQuery 3745 } 3746 3747 request.Method = "POST" 3748 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3749 if err != nil { 3750 return out, metadata, &smithy.SerializationError{Err: err} 3751 } 3752 3753 restEncoder.SetHeader("Content-Type").String("application/json") 3754 3755 jsonEncoder := smithyjson.NewEncoder() 3756 if err := awsRestjson1_serializeOpDocumentPutAccountDetailsInput(input, jsonEncoder.Value); err != nil { 3757 return out, metadata, &smithy.SerializationError{Err: err} 3758 } 3759 3760 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3761 return out, metadata, &smithy.SerializationError{Err: err} 3762 } 3763 3764 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3765 return out, metadata, &smithy.SerializationError{Err: err} 3766 } 3767 in.Request = request 3768 3769 return next.HandleSerialize(ctx, in) 3770} 3771func awsRestjson1_serializeOpHttpBindingsPutAccountDetailsInput(v *PutAccountDetailsInput, encoder *httpbinding.Encoder) error { 3772 if v == nil { 3773 return fmt.Errorf("unsupported serialization of nil %T", v) 3774 } 3775 3776 return nil 3777} 3778 3779func awsRestjson1_serializeOpDocumentPutAccountDetailsInput(v *PutAccountDetailsInput, value smithyjson.Value) error { 3780 object := value.Object() 3781 defer object.Close() 3782 3783 if v.AdditionalContactEmailAddresses != nil { 3784 ok := object.Key("AdditionalContactEmailAddresses") 3785 if err := awsRestjson1_serializeDocumentAdditionalContactEmailAddresses(v.AdditionalContactEmailAddresses, ok); err != nil { 3786 return err 3787 } 3788 } 3789 3790 if len(v.ContactLanguage) > 0 { 3791 ok := object.Key("ContactLanguage") 3792 ok.String(string(v.ContactLanguage)) 3793 } 3794 3795 if len(v.MailType) > 0 { 3796 ok := object.Key("MailType") 3797 ok.String(string(v.MailType)) 3798 } 3799 3800 if v.ProductionAccessEnabled != nil { 3801 ok := object.Key("ProductionAccessEnabled") 3802 ok.Boolean(*v.ProductionAccessEnabled) 3803 } 3804 3805 if v.UseCaseDescription != nil { 3806 ok := object.Key("UseCaseDescription") 3807 ok.String(*v.UseCaseDescription) 3808 } 3809 3810 if v.WebsiteURL != nil { 3811 ok := object.Key("WebsiteURL") 3812 ok.String(*v.WebsiteURL) 3813 } 3814 3815 return nil 3816} 3817 3818type awsRestjson1_serializeOpPutAccountSendingAttributes struct { 3819} 3820 3821func (*awsRestjson1_serializeOpPutAccountSendingAttributes) ID() string { 3822 return "OperationSerializer" 3823} 3824 3825func (m *awsRestjson1_serializeOpPutAccountSendingAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3826 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3827) { 3828 request, ok := in.Request.(*smithyhttp.Request) 3829 if !ok { 3830 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3831 } 3832 3833 input, ok := in.Parameters.(*PutAccountSendingAttributesInput) 3834 _ = input 3835 if !ok { 3836 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3837 } 3838 3839 opPath, opQuery := httpbinding.SplitURI("/v2/email/account/sending") 3840 request.URL.Path = opPath 3841 if len(request.URL.RawQuery) > 0 { 3842 request.URL.RawQuery = "&" + opQuery 3843 } else { 3844 request.URL.RawQuery = opQuery 3845 } 3846 3847 request.Method = "PUT" 3848 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3849 if err != nil { 3850 return out, metadata, &smithy.SerializationError{Err: err} 3851 } 3852 3853 restEncoder.SetHeader("Content-Type").String("application/json") 3854 3855 jsonEncoder := smithyjson.NewEncoder() 3856 if err := awsRestjson1_serializeOpDocumentPutAccountSendingAttributesInput(input, jsonEncoder.Value); err != nil { 3857 return out, metadata, &smithy.SerializationError{Err: err} 3858 } 3859 3860 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3861 return out, metadata, &smithy.SerializationError{Err: err} 3862 } 3863 3864 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3865 return out, metadata, &smithy.SerializationError{Err: err} 3866 } 3867 in.Request = request 3868 3869 return next.HandleSerialize(ctx, in) 3870} 3871func awsRestjson1_serializeOpHttpBindingsPutAccountSendingAttributesInput(v *PutAccountSendingAttributesInput, encoder *httpbinding.Encoder) error { 3872 if v == nil { 3873 return fmt.Errorf("unsupported serialization of nil %T", v) 3874 } 3875 3876 return nil 3877} 3878 3879func awsRestjson1_serializeOpDocumentPutAccountSendingAttributesInput(v *PutAccountSendingAttributesInput, value smithyjson.Value) error { 3880 object := value.Object() 3881 defer object.Close() 3882 3883 if v.SendingEnabled { 3884 ok := object.Key("SendingEnabled") 3885 ok.Boolean(v.SendingEnabled) 3886 } 3887 3888 return nil 3889} 3890 3891type awsRestjson1_serializeOpPutAccountSuppressionAttributes struct { 3892} 3893 3894func (*awsRestjson1_serializeOpPutAccountSuppressionAttributes) ID() string { 3895 return "OperationSerializer" 3896} 3897 3898func (m *awsRestjson1_serializeOpPutAccountSuppressionAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3899 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3900) { 3901 request, ok := in.Request.(*smithyhttp.Request) 3902 if !ok { 3903 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3904 } 3905 3906 input, ok := in.Parameters.(*PutAccountSuppressionAttributesInput) 3907 _ = input 3908 if !ok { 3909 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3910 } 3911 3912 opPath, opQuery := httpbinding.SplitURI("/v2/email/account/suppression") 3913 request.URL.Path = opPath 3914 if len(request.URL.RawQuery) > 0 { 3915 request.URL.RawQuery = "&" + opQuery 3916 } else { 3917 request.URL.RawQuery = opQuery 3918 } 3919 3920 request.Method = "PUT" 3921 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3922 if err != nil { 3923 return out, metadata, &smithy.SerializationError{Err: err} 3924 } 3925 3926 restEncoder.SetHeader("Content-Type").String("application/json") 3927 3928 jsonEncoder := smithyjson.NewEncoder() 3929 if err := awsRestjson1_serializeOpDocumentPutAccountSuppressionAttributesInput(input, jsonEncoder.Value); err != nil { 3930 return out, metadata, &smithy.SerializationError{Err: err} 3931 } 3932 3933 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 3934 return out, metadata, &smithy.SerializationError{Err: err} 3935 } 3936 3937 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 3938 return out, metadata, &smithy.SerializationError{Err: err} 3939 } 3940 in.Request = request 3941 3942 return next.HandleSerialize(ctx, in) 3943} 3944func awsRestjson1_serializeOpHttpBindingsPutAccountSuppressionAttributesInput(v *PutAccountSuppressionAttributesInput, encoder *httpbinding.Encoder) error { 3945 if v == nil { 3946 return fmt.Errorf("unsupported serialization of nil %T", v) 3947 } 3948 3949 return nil 3950} 3951 3952func awsRestjson1_serializeOpDocumentPutAccountSuppressionAttributesInput(v *PutAccountSuppressionAttributesInput, value smithyjson.Value) error { 3953 object := value.Object() 3954 defer object.Close() 3955 3956 if v.SuppressedReasons != nil { 3957 ok := object.Key("SuppressedReasons") 3958 if err := awsRestjson1_serializeDocumentSuppressionListReasons(v.SuppressedReasons, ok); err != nil { 3959 return err 3960 } 3961 } 3962 3963 return nil 3964} 3965 3966type awsRestjson1_serializeOpPutConfigurationSetDeliveryOptions struct { 3967} 3968 3969func (*awsRestjson1_serializeOpPutConfigurationSetDeliveryOptions) ID() string { 3970 return "OperationSerializer" 3971} 3972 3973func (m *awsRestjson1_serializeOpPutConfigurationSetDeliveryOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3974 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3975) { 3976 request, ok := in.Request.(*smithyhttp.Request) 3977 if !ok { 3978 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3979 } 3980 3981 input, ok := in.Parameters.(*PutConfigurationSetDeliveryOptionsInput) 3982 _ = input 3983 if !ok { 3984 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3985 } 3986 3987 opPath, opQuery := httpbinding.SplitURI("/v2/email/configuration-sets/{ConfigurationSetName}/delivery-options") 3988 request.URL.Path = opPath 3989 if len(request.URL.RawQuery) > 0 { 3990 request.URL.RawQuery = "&" + opQuery 3991 } else { 3992 request.URL.RawQuery = opQuery 3993 } 3994 3995 request.Method = "PUT" 3996 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3997 if err != nil { 3998 return out, metadata, &smithy.SerializationError{Err: err} 3999 } 4000 4001 if err := awsRestjson1_serializeOpHttpBindingsPutConfigurationSetDeliveryOptionsInput(input, restEncoder); err != nil { 4002 return out, metadata, &smithy.SerializationError{Err: err} 4003 } 4004 4005 restEncoder.SetHeader("Content-Type").String("application/json") 4006 4007 jsonEncoder := smithyjson.NewEncoder() 4008 if err := awsRestjson1_serializeOpDocumentPutConfigurationSetDeliveryOptionsInput(input, jsonEncoder.Value); err != nil { 4009 return out, metadata, &smithy.SerializationError{Err: err} 4010 } 4011 4012 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4013 return out, metadata, &smithy.SerializationError{Err: err} 4014 } 4015 4016 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4017 return out, metadata, &smithy.SerializationError{Err: err} 4018 } 4019 in.Request = request 4020 4021 return next.HandleSerialize(ctx, in) 4022} 4023func awsRestjson1_serializeOpHttpBindingsPutConfigurationSetDeliveryOptionsInput(v *PutConfigurationSetDeliveryOptionsInput, encoder *httpbinding.Encoder) error { 4024 if v == nil { 4025 return fmt.Errorf("unsupported serialization of nil %T", v) 4026 } 4027 4028 if v.ConfigurationSetName == nil || len(*v.ConfigurationSetName) == 0 { 4029 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationSetName must not be empty")} 4030 } 4031 if v.ConfigurationSetName != nil { 4032 if err := encoder.SetURI("ConfigurationSetName").String(*v.ConfigurationSetName); err != nil { 4033 return err 4034 } 4035 } 4036 4037 return nil 4038} 4039 4040func awsRestjson1_serializeOpDocumentPutConfigurationSetDeliveryOptionsInput(v *PutConfigurationSetDeliveryOptionsInput, value smithyjson.Value) error { 4041 object := value.Object() 4042 defer object.Close() 4043 4044 if v.SendingPoolName != nil { 4045 ok := object.Key("SendingPoolName") 4046 ok.String(*v.SendingPoolName) 4047 } 4048 4049 if len(v.TlsPolicy) > 0 { 4050 ok := object.Key("TlsPolicy") 4051 ok.String(string(v.TlsPolicy)) 4052 } 4053 4054 return nil 4055} 4056 4057type awsRestjson1_serializeOpPutConfigurationSetReputationOptions struct { 4058} 4059 4060func (*awsRestjson1_serializeOpPutConfigurationSetReputationOptions) ID() string { 4061 return "OperationSerializer" 4062} 4063 4064func (m *awsRestjson1_serializeOpPutConfigurationSetReputationOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4065 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4066) { 4067 request, ok := in.Request.(*smithyhttp.Request) 4068 if !ok { 4069 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4070 } 4071 4072 input, ok := in.Parameters.(*PutConfigurationSetReputationOptionsInput) 4073 _ = input 4074 if !ok { 4075 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4076 } 4077 4078 opPath, opQuery := httpbinding.SplitURI("/v2/email/configuration-sets/{ConfigurationSetName}/reputation-options") 4079 request.URL.Path = opPath 4080 if len(request.URL.RawQuery) > 0 { 4081 request.URL.RawQuery = "&" + opQuery 4082 } else { 4083 request.URL.RawQuery = opQuery 4084 } 4085 4086 request.Method = "PUT" 4087 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4088 if err != nil { 4089 return out, metadata, &smithy.SerializationError{Err: err} 4090 } 4091 4092 if err := awsRestjson1_serializeOpHttpBindingsPutConfigurationSetReputationOptionsInput(input, restEncoder); err != nil { 4093 return out, metadata, &smithy.SerializationError{Err: err} 4094 } 4095 4096 restEncoder.SetHeader("Content-Type").String("application/json") 4097 4098 jsonEncoder := smithyjson.NewEncoder() 4099 if err := awsRestjson1_serializeOpDocumentPutConfigurationSetReputationOptionsInput(input, jsonEncoder.Value); err != nil { 4100 return out, metadata, &smithy.SerializationError{Err: err} 4101 } 4102 4103 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4104 return out, metadata, &smithy.SerializationError{Err: err} 4105 } 4106 4107 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4108 return out, metadata, &smithy.SerializationError{Err: err} 4109 } 4110 in.Request = request 4111 4112 return next.HandleSerialize(ctx, in) 4113} 4114func awsRestjson1_serializeOpHttpBindingsPutConfigurationSetReputationOptionsInput(v *PutConfigurationSetReputationOptionsInput, encoder *httpbinding.Encoder) error { 4115 if v == nil { 4116 return fmt.Errorf("unsupported serialization of nil %T", v) 4117 } 4118 4119 if v.ConfigurationSetName == nil || len(*v.ConfigurationSetName) == 0 { 4120 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationSetName must not be empty")} 4121 } 4122 if v.ConfigurationSetName != nil { 4123 if err := encoder.SetURI("ConfigurationSetName").String(*v.ConfigurationSetName); err != nil { 4124 return err 4125 } 4126 } 4127 4128 return nil 4129} 4130 4131func awsRestjson1_serializeOpDocumentPutConfigurationSetReputationOptionsInput(v *PutConfigurationSetReputationOptionsInput, value smithyjson.Value) error { 4132 object := value.Object() 4133 defer object.Close() 4134 4135 if v.ReputationMetricsEnabled { 4136 ok := object.Key("ReputationMetricsEnabled") 4137 ok.Boolean(v.ReputationMetricsEnabled) 4138 } 4139 4140 return nil 4141} 4142 4143type awsRestjson1_serializeOpPutConfigurationSetSendingOptions struct { 4144} 4145 4146func (*awsRestjson1_serializeOpPutConfigurationSetSendingOptions) ID() string { 4147 return "OperationSerializer" 4148} 4149 4150func (m *awsRestjson1_serializeOpPutConfigurationSetSendingOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4151 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4152) { 4153 request, ok := in.Request.(*smithyhttp.Request) 4154 if !ok { 4155 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4156 } 4157 4158 input, ok := in.Parameters.(*PutConfigurationSetSendingOptionsInput) 4159 _ = input 4160 if !ok { 4161 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4162 } 4163 4164 opPath, opQuery := httpbinding.SplitURI("/v2/email/configuration-sets/{ConfigurationSetName}/sending") 4165 request.URL.Path = opPath 4166 if len(request.URL.RawQuery) > 0 { 4167 request.URL.RawQuery = "&" + opQuery 4168 } else { 4169 request.URL.RawQuery = opQuery 4170 } 4171 4172 request.Method = "PUT" 4173 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4174 if err != nil { 4175 return out, metadata, &smithy.SerializationError{Err: err} 4176 } 4177 4178 if err := awsRestjson1_serializeOpHttpBindingsPutConfigurationSetSendingOptionsInput(input, restEncoder); err != nil { 4179 return out, metadata, &smithy.SerializationError{Err: err} 4180 } 4181 4182 restEncoder.SetHeader("Content-Type").String("application/json") 4183 4184 jsonEncoder := smithyjson.NewEncoder() 4185 if err := awsRestjson1_serializeOpDocumentPutConfigurationSetSendingOptionsInput(input, jsonEncoder.Value); err != nil { 4186 return out, metadata, &smithy.SerializationError{Err: err} 4187 } 4188 4189 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4190 return out, metadata, &smithy.SerializationError{Err: err} 4191 } 4192 4193 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4194 return out, metadata, &smithy.SerializationError{Err: err} 4195 } 4196 in.Request = request 4197 4198 return next.HandleSerialize(ctx, in) 4199} 4200func awsRestjson1_serializeOpHttpBindingsPutConfigurationSetSendingOptionsInput(v *PutConfigurationSetSendingOptionsInput, encoder *httpbinding.Encoder) error { 4201 if v == nil { 4202 return fmt.Errorf("unsupported serialization of nil %T", v) 4203 } 4204 4205 if v.ConfigurationSetName == nil || len(*v.ConfigurationSetName) == 0 { 4206 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationSetName must not be empty")} 4207 } 4208 if v.ConfigurationSetName != nil { 4209 if err := encoder.SetURI("ConfigurationSetName").String(*v.ConfigurationSetName); err != nil { 4210 return err 4211 } 4212 } 4213 4214 return nil 4215} 4216 4217func awsRestjson1_serializeOpDocumentPutConfigurationSetSendingOptionsInput(v *PutConfigurationSetSendingOptionsInput, value smithyjson.Value) error { 4218 object := value.Object() 4219 defer object.Close() 4220 4221 if v.SendingEnabled { 4222 ok := object.Key("SendingEnabled") 4223 ok.Boolean(v.SendingEnabled) 4224 } 4225 4226 return nil 4227} 4228 4229type awsRestjson1_serializeOpPutConfigurationSetSuppressionOptions struct { 4230} 4231 4232func (*awsRestjson1_serializeOpPutConfigurationSetSuppressionOptions) ID() string { 4233 return "OperationSerializer" 4234} 4235 4236func (m *awsRestjson1_serializeOpPutConfigurationSetSuppressionOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4237 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4238) { 4239 request, ok := in.Request.(*smithyhttp.Request) 4240 if !ok { 4241 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4242 } 4243 4244 input, ok := in.Parameters.(*PutConfigurationSetSuppressionOptionsInput) 4245 _ = input 4246 if !ok { 4247 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4248 } 4249 4250 opPath, opQuery := httpbinding.SplitURI("/v2/email/configuration-sets/{ConfigurationSetName}/suppression-options") 4251 request.URL.Path = opPath 4252 if len(request.URL.RawQuery) > 0 { 4253 request.URL.RawQuery = "&" + opQuery 4254 } else { 4255 request.URL.RawQuery = opQuery 4256 } 4257 4258 request.Method = "PUT" 4259 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4260 if err != nil { 4261 return out, metadata, &smithy.SerializationError{Err: err} 4262 } 4263 4264 if err := awsRestjson1_serializeOpHttpBindingsPutConfigurationSetSuppressionOptionsInput(input, restEncoder); err != nil { 4265 return out, metadata, &smithy.SerializationError{Err: err} 4266 } 4267 4268 restEncoder.SetHeader("Content-Type").String("application/json") 4269 4270 jsonEncoder := smithyjson.NewEncoder() 4271 if err := awsRestjson1_serializeOpDocumentPutConfigurationSetSuppressionOptionsInput(input, jsonEncoder.Value); err != nil { 4272 return out, metadata, &smithy.SerializationError{Err: err} 4273 } 4274 4275 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4276 return out, metadata, &smithy.SerializationError{Err: err} 4277 } 4278 4279 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4280 return out, metadata, &smithy.SerializationError{Err: err} 4281 } 4282 in.Request = request 4283 4284 return next.HandleSerialize(ctx, in) 4285} 4286func awsRestjson1_serializeOpHttpBindingsPutConfigurationSetSuppressionOptionsInput(v *PutConfigurationSetSuppressionOptionsInput, encoder *httpbinding.Encoder) error { 4287 if v == nil { 4288 return fmt.Errorf("unsupported serialization of nil %T", v) 4289 } 4290 4291 if v.ConfigurationSetName == nil || len(*v.ConfigurationSetName) == 0 { 4292 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationSetName must not be empty")} 4293 } 4294 if v.ConfigurationSetName != nil { 4295 if err := encoder.SetURI("ConfigurationSetName").String(*v.ConfigurationSetName); err != nil { 4296 return err 4297 } 4298 } 4299 4300 return nil 4301} 4302 4303func awsRestjson1_serializeOpDocumentPutConfigurationSetSuppressionOptionsInput(v *PutConfigurationSetSuppressionOptionsInput, value smithyjson.Value) error { 4304 object := value.Object() 4305 defer object.Close() 4306 4307 if v.SuppressedReasons != nil { 4308 ok := object.Key("SuppressedReasons") 4309 if err := awsRestjson1_serializeDocumentSuppressionListReasons(v.SuppressedReasons, ok); err != nil { 4310 return err 4311 } 4312 } 4313 4314 return nil 4315} 4316 4317type awsRestjson1_serializeOpPutConfigurationSetTrackingOptions struct { 4318} 4319 4320func (*awsRestjson1_serializeOpPutConfigurationSetTrackingOptions) ID() string { 4321 return "OperationSerializer" 4322} 4323 4324func (m *awsRestjson1_serializeOpPutConfigurationSetTrackingOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4325 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4326) { 4327 request, ok := in.Request.(*smithyhttp.Request) 4328 if !ok { 4329 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4330 } 4331 4332 input, ok := in.Parameters.(*PutConfigurationSetTrackingOptionsInput) 4333 _ = input 4334 if !ok { 4335 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4336 } 4337 4338 opPath, opQuery := httpbinding.SplitURI("/v2/email/configuration-sets/{ConfigurationSetName}/tracking-options") 4339 request.URL.Path = opPath 4340 if len(request.URL.RawQuery) > 0 { 4341 request.URL.RawQuery = "&" + opQuery 4342 } else { 4343 request.URL.RawQuery = opQuery 4344 } 4345 4346 request.Method = "PUT" 4347 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4348 if err != nil { 4349 return out, metadata, &smithy.SerializationError{Err: err} 4350 } 4351 4352 if err := awsRestjson1_serializeOpHttpBindingsPutConfigurationSetTrackingOptionsInput(input, restEncoder); err != nil { 4353 return out, metadata, &smithy.SerializationError{Err: err} 4354 } 4355 4356 restEncoder.SetHeader("Content-Type").String("application/json") 4357 4358 jsonEncoder := smithyjson.NewEncoder() 4359 if err := awsRestjson1_serializeOpDocumentPutConfigurationSetTrackingOptionsInput(input, jsonEncoder.Value); err != nil { 4360 return out, metadata, &smithy.SerializationError{Err: err} 4361 } 4362 4363 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4364 return out, metadata, &smithy.SerializationError{Err: err} 4365 } 4366 4367 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4368 return out, metadata, &smithy.SerializationError{Err: err} 4369 } 4370 in.Request = request 4371 4372 return next.HandleSerialize(ctx, in) 4373} 4374func awsRestjson1_serializeOpHttpBindingsPutConfigurationSetTrackingOptionsInput(v *PutConfigurationSetTrackingOptionsInput, encoder *httpbinding.Encoder) error { 4375 if v == nil { 4376 return fmt.Errorf("unsupported serialization of nil %T", v) 4377 } 4378 4379 if v.ConfigurationSetName == nil || len(*v.ConfigurationSetName) == 0 { 4380 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationSetName must not be empty")} 4381 } 4382 if v.ConfigurationSetName != nil { 4383 if err := encoder.SetURI("ConfigurationSetName").String(*v.ConfigurationSetName); err != nil { 4384 return err 4385 } 4386 } 4387 4388 return nil 4389} 4390 4391func awsRestjson1_serializeOpDocumentPutConfigurationSetTrackingOptionsInput(v *PutConfigurationSetTrackingOptionsInput, value smithyjson.Value) error { 4392 object := value.Object() 4393 defer object.Close() 4394 4395 if v.CustomRedirectDomain != nil { 4396 ok := object.Key("CustomRedirectDomain") 4397 ok.String(*v.CustomRedirectDomain) 4398 } 4399 4400 return nil 4401} 4402 4403type awsRestjson1_serializeOpPutDedicatedIpInPool struct { 4404} 4405 4406func (*awsRestjson1_serializeOpPutDedicatedIpInPool) ID() string { 4407 return "OperationSerializer" 4408} 4409 4410func (m *awsRestjson1_serializeOpPutDedicatedIpInPool) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4411 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4412) { 4413 request, ok := in.Request.(*smithyhttp.Request) 4414 if !ok { 4415 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4416 } 4417 4418 input, ok := in.Parameters.(*PutDedicatedIpInPoolInput) 4419 _ = input 4420 if !ok { 4421 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4422 } 4423 4424 opPath, opQuery := httpbinding.SplitURI("/v2/email/dedicated-ips/{Ip}/pool") 4425 request.URL.Path = opPath 4426 if len(request.URL.RawQuery) > 0 { 4427 request.URL.RawQuery = "&" + opQuery 4428 } else { 4429 request.URL.RawQuery = opQuery 4430 } 4431 4432 request.Method = "PUT" 4433 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4434 if err != nil { 4435 return out, metadata, &smithy.SerializationError{Err: err} 4436 } 4437 4438 if err := awsRestjson1_serializeOpHttpBindingsPutDedicatedIpInPoolInput(input, restEncoder); err != nil { 4439 return out, metadata, &smithy.SerializationError{Err: err} 4440 } 4441 4442 restEncoder.SetHeader("Content-Type").String("application/json") 4443 4444 jsonEncoder := smithyjson.NewEncoder() 4445 if err := awsRestjson1_serializeOpDocumentPutDedicatedIpInPoolInput(input, jsonEncoder.Value); err != nil { 4446 return out, metadata, &smithy.SerializationError{Err: err} 4447 } 4448 4449 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4450 return out, metadata, &smithy.SerializationError{Err: err} 4451 } 4452 4453 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4454 return out, metadata, &smithy.SerializationError{Err: err} 4455 } 4456 in.Request = request 4457 4458 return next.HandleSerialize(ctx, in) 4459} 4460func awsRestjson1_serializeOpHttpBindingsPutDedicatedIpInPoolInput(v *PutDedicatedIpInPoolInput, encoder *httpbinding.Encoder) error { 4461 if v == nil { 4462 return fmt.Errorf("unsupported serialization of nil %T", v) 4463 } 4464 4465 if v.Ip == nil || len(*v.Ip) == 0 { 4466 return &smithy.SerializationError{Err: fmt.Errorf("input member Ip must not be empty")} 4467 } 4468 if v.Ip != nil { 4469 if err := encoder.SetURI("Ip").String(*v.Ip); err != nil { 4470 return err 4471 } 4472 } 4473 4474 return nil 4475} 4476 4477func awsRestjson1_serializeOpDocumentPutDedicatedIpInPoolInput(v *PutDedicatedIpInPoolInput, value smithyjson.Value) error { 4478 object := value.Object() 4479 defer object.Close() 4480 4481 if v.DestinationPoolName != nil { 4482 ok := object.Key("DestinationPoolName") 4483 ok.String(*v.DestinationPoolName) 4484 } 4485 4486 return nil 4487} 4488 4489type awsRestjson1_serializeOpPutDedicatedIpWarmupAttributes struct { 4490} 4491 4492func (*awsRestjson1_serializeOpPutDedicatedIpWarmupAttributes) ID() string { 4493 return "OperationSerializer" 4494} 4495 4496func (m *awsRestjson1_serializeOpPutDedicatedIpWarmupAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4497 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4498) { 4499 request, ok := in.Request.(*smithyhttp.Request) 4500 if !ok { 4501 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4502 } 4503 4504 input, ok := in.Parameters.(*PutDedicatedIpWarmupAttributesInput) 4505 _ = input 4506 if !ok { 4507 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4508 } 4509 4510 opPath, opQuery := httpbinding.SplitURI("/v2/email/dedicated-ips/{Ip}/warmup") 4511 request.URL.Path = opPath 4512 if len(request.URL.RawQuery) > 0 { 4513 request.URL.RawQuery = "&" + opQuery 4514 } else { 4515 request.URL.RawQuery = opQuery 4516 } 4517 4518 request.Method = "PUT" 4519 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4520 if err != nil { 4521 return out, metadata, &smithy.SerializationError{Err: err} 4522 } 4523 4524 if err := awsRestjson1_serializeOpHttpBindingsPutDedicatedIpWarmupAttributesInput(input, restEncoder); err != nil { 4525 return out, metadata, &smithy.SerializationError{Err: err} 4526 } 4527 4528 restEncoder.SetHeader("Content-Type").String("application/json") 4529 4530 jsonEncoder := smithyjson.NewEncoder() 4531 if err := awsRestjson1_serializeOpDocumentPutDedicatedIpWarmupAttributesInput(input, jsonEncoder.Value); err != nil { 4532 return out, metadata, &smithy.SerializationError{Err: err} 4533 } 4534 4535 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4536 return out, metadata, &smithy.SerializationError{Err: err} 4537 } 4538 4539 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4540 return out, metadata, &smithy.SerializationError{Err: err} 4541 } 4542 in.Request = request 4543 4544 return next.HandleSerialize(ctx, in) 4545} 4546func awsRestjson1_serializeOpHttpBindingsPutDedicatedIpWarmupAttributesInput(v *PutDedicatedIpWarmupAttributesInput, encoder *httpbinding.Encoder) error { 4547 if v == nil { 4548 return fmt.Errorf("unsupported serialization of nil %T", v) 4549 } 4550 4551 if v.Ip == nil || len(*v.Ip) == 0 { 4552 return &smithy.SerializationError{Err: fmt.Errorf("input member Ip must not be empty")} 4553 } 4554 if v.Ip != nil { 4555 if err := encoder.SetURI("Ip").String(*v.Ip); err != nil { 4556 return err 4557 } 4558 } 4559 4560 return nil 4561} 4562 4563func awsRestjson1_serializeOpDocumentPutDedicatedIpWarmupAttributesInput(v *PutDedicatedIpWarmupAttributesInput, value smithyjson.Value) error { 4564 object := value.Object() 4565 defer object.Close() 4566 4567 if v.WarmupPercentage != nil { 4568 ok := object.Key("WarmupPercentage") 4569 ok.Integer(*v.WarmupPercentage) 4570 } 4571 4572 return nil 4573} 4574 4575type awsRestjson1_serializeOpPutDeliverabilityDashboardOption struct { 4576} 4577 4578func (*awsRestjson1_serializeOpPutDeliverabilityDashboardOption) ID() string { 4579 return "OperationSerializer" 4580} 4581 4582func (m *awsRestjson1_serializeOpPutDeliverabilityDashboardOption) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4583 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4584) { 4585 request, ok := in.Request.(*smithyhttp.Request) 4586 if !ok { 4587 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4588 } 4589 4590 input, ok := in.Parameters.(*PutDeliverabilityDashboardOptionInput) 4591 _ = input 4592 if !ok { 4593 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4594 } 4595 4596 opPath, opQuery := httpbinding.SplitURI("/v2/email/deliverability-dashboard") 4597 request.URL.Path = opPath 4598 if len(request.URL.RawQuery) > 0 { 4599 request.URL.RawQuery = "&" + opQuery 4600 } else { 4601 request.URL.RawQuery = opQuery 4602 } 4603 4604 request.Method = "PUT" 4605 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4606 if err != nil { 4607 return out, metadata, &smithy.SerializationError{Err: err} 4608 } 4609 4610 restEncoder.SetHeader("Content-Type").String("application/json") 4611 4612 jsonEncoder := smithyjson.NewEncoder() 4613 if err := awsRestjson1_serializeOpDocumentPutDeliverabilityDashboardOptionInput(input, jsonEncoder.Value); err != nil { 4614 return out, metadata, &smithy.SerializationError{Err: err} 4615 } 4616 4617 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4618 return out, metadata, &smithy.SerializationError{Err: err} 4619 } 4620 4621 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4622 return out, metadata, &smithy.SerializationError{Err: err} 4623 } 4624 in.Request = request 4625 4626 return next.HandleSerialize(ctx, in) 4627} 4628func awsRestjson1_serializeOpHttpBindingsPutDeliverabilityDashboardOptionInput(v *PutDeliverabilityDashboardOptionInput, encoder *httpbinding.Encoder) error { 4629 if v == nil { 4630 return fmt.Errorf("unsupported serialization of nil %T", v) 4631 } 4632 4633 return nil 4634} 4635 4636func awsRestjson1_serializeOpDocumentPutDeliverabilityDashboardOptionInput(v *PutDeliverabilityDashboardOptionInput, value smithyjson.Value) error { 4637 object := value.Object() 4638 defer object.Close() 4639 4640 if v.DashboardEnabled { 4641 ok := object.Key("DashboardEnabled") 4642 ok.Boolean(v.DashboardEnabled) 4643 } 4644 4645 if v.SubscribedDomains != nil { 4646 ok := object.Key("SubscribedDomains") 4647 if err := awsRestjson1_serializeDocumentDomainDeliverabilityTrackingOptions(v.SubscribedDomains, ok); err != nil { 4648 return err 4649 } 4650 } 4651 4652 return nil 4653} 4654 4655type awsRestjson1_serializeOpPutEmailIdentityDkimAttributes struct { 4656} 4657 4658func (*awsRestjson1_serializeOpPutEmailIdentityDkimAttributes) ID() string { 4659 return "OperationSerializer" 4660} 4661 4662func (m *awsRestjson1_serializeOpPutEmailIdentityDkimAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4663 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4664) { 4665 request, ok := in.Request.(*smithyhttp.Request) 4666 if !ok { 4667 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4668 } 4669 4670 input, ok := in.Parameters.(*PutEmailIdentityDkimAttributesInput) 4671 _ = input 4672 if !ok { 4673 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4674 } 4675 4676 opPath, opQuery := httpbinding.SplitURI("/v2/email/identities/{EmailIdentity}/dkim") 4677 request.URL.Path = opPath 4678 if len(request.URL.RawQuery) > 0 { 4679 request.URL.RawQuery = "&" + opQuery 4680 } else { 4681 request.URL.RawQuery = opQuery 4682 } 4683 4684 request.Method = "PUT" 4685 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4686 if err != nil { 4687 return out, metadata, &smithy.SerializationError{Err: err} 4688 } 4689 4690 if err := awsRestjson1_serializeOpHttpBindingsPutEmailIdentityDkimAttributesInput(input, restEncoder); err != nil { 4691 return out, metadata, &smithy.SerializationError{Err: err} 4692 } 4693 4694 restEncoder.SetHeader("Content-Type").String("application/json") 4695 4696 jsonEncoder := smithyjson.NewEncoder() 4697 if err := awsRestjson1_serializeOpDocumentPutEmailIdentityDkimAttributesInput(input, jsonEncoder.Value); err != nil { 4698 return out, metadata, &smithy.SerializationError{Err: err} 4699 } 4700 4701 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4702 return out, metadata, &smithy.SerializationError{Err: err} 4703 } 4704 4705 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4706 return out, metadata, &smithy.SerializationError{Err: err} 4707 } 4708 in.Request = request 4709 4710 return next.HandleSerialize(ctx, in) 4711} 4712func awsRestjson1_serializeOpHttpBindingsPutEmailIdentityDkimAttributesInput(v *PutEmailIdentityDkimAttributesInput, encoder *httpbinding.Encoder) error { 4713 if v == nil { 4714 return fmt.Errorf("unsupported serialization of nil %T", v) 4715 } 4716 4717 if v.EmailIdentity == nil || len(*v.EmailIdentity) == 0 { 4718 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailIdentity must not be empty")} 4719 } 4720 if v.EmailIdentity != nil { 4721 if err := encoder.SetURI("EmailIdentity").String(*v.EmailIdentity); err != nil { 4722 return err 4723 } 4724 } 4725 4726 return nil 4727} 4728 4729func awsRestjson1_serializeOpDocumentPutEmailIdentityDkimAttributesInput(v *PutEmailIdentityDkimAttributesInput, value smithyjson.Value) error { 4730 object := value.Object() 4731 defer object.Close() 4732 4733 if v.SigningEnabled { 4734 ok := object.Key("SigningEnabled") 4735 ok.Boolean(v.SigningEnabled) 4736 } 4737 4738 return nil 4739} 4740 4741type awsRestjson1_serializeOpPutEmailIdentityDkimSigningAttributes struct { 4742} 4743 4744func (*awsRestjson1_serializeOpPutEmailIdentityDkimSigningAttributes) ID() string { 4745 return "OperationSerializer" 4746} 4747 4748func (m *awsRestjson1_serializeOpPutEmailIdentityDkimSigningAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4749 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4750) { 4751 request, ok := in.Request.(*smithyhttp.Request) 4752 if !ok { 4753 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4754 } 4755 4756 input, ok := in.Parameters.(*PutEmailIdentityDkimSigningAttributesInput) 4757 _ = input 4758 if !ok { 4759 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4760 } 4761 4762 opPath, opQuery := httpbinding.SplitURI("/v1/email/identities/{EmailIdentity}/dkim/signing") 4763 request.URL.Path = opPath 4764 if len(request.URL.RawQuery) > 0 { 4765 request.URL.RawQuery = "&" + opQuery 4766 } else { 4767 request.URL.RawQuery = opQuery 4768 } 4769 4770 request.Method = "PUT" 4771 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4772 if err != nil { 4773 return out, metadata, &smithy.SerializationError{Err: err} 4774 } 4775 4776 if err := awsRestjson1_serializeOpHttpBindingsPutEmailIdentityDkimSigningAttributesInput(input, restEncoder); err != nil { 4777 return out, metadata, &smithy.SerializationError{Err: err} 4778 } 4779 4780 restEncoder.SetHeader("Content-Type").String("application/json") 4781 4782 jsonEncoder := smithyjson.NewEncoder() 4783 if err := awsRestjson1_serializeOpDocumentPutEmailIdentityDkimSigningAttributesInput(input, jsonEncoder.Value); err != nil { 4784 return out, metadata, &smithy.SerializationError{Err: err} 4785 } 4786 4787 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4788 return out, metadata, &smithy.SerializationError{Err: err} 4789 } 4790 4791 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4792 return out, metadata, &smithy.SerializationError{Err: err} 4793 } 4794 in.Request = request 4795 4796 return next.HandleSerialize(ctx, in) 4797} 4798func awsRestjson1_serializeOpHttpBindingsPutEmailIdentityDkimSigningAttributesInput(v *PutEmailIdentityDkimSigningAttributesInput, encoder *httpbinding.Encoder) error { 4799 if v == nil { 4800 return fmt.Errorf("unsupported serialization of nil %T", v) 4801 } 4802 4803 if v.EmailIdentity == nil || len(*v.EmailIdentity) == 0 { 4804 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailIdentity must not be empty")} 4805 } 4806 if v.EmailIdentity != nil { 4807 if err := encoder.SetURI("EmailIdentity").String(*v.EmailIdentity); err != nil { 4808 return err 4809 } 4810 } 4811 4812 return nil 4813} 4814 4815func awsRestjson1_serializeOpDocumentPutEmailIdentityDkimSigningAttributesInput(v *PutEmailIdentityDkimSigningAttributesInput, value smithyjson.Value) error { 4816 object := value.Object() 4817 defer object.Close() 4818 4819 if v.SigningAttributes != nil { 4820 ok := object.Key("SigningAttributes") 4821 if err := awsRestjson1_serializeDocumentDkimSigningAttributes(v.SigningAttributes, ok); err != nil { 4822 return err 4823 } 4824 } 4825 4826 if len(v.SigningAttributesOrigin) > 0 { 4827 ok := object.Key("SigningAttributesOrigin") 4828 ok.String(string(v.SigningAttributesOrigin)) 4829 } 4830 4831 return nil 4832} 4833 4834type awsRestjson1_serializeOpPutEmailIdentityFeedbackAttributes struct { 4835} 4836 4837func (*awsRestjson1_serializeOpPutEmailIdentityFeedbackAttributes) ID() string { 4838 return "OperationSerializer" 4839} 4840 4841func (m *awsRestjson1_serializeOpPutEmailIdentityFeedbackAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4842 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4843) { 4844 request, ok := in.Request.(*smithyhttp.Request) 4845 if !ok { 4846 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4847 } 4848 4849 input, ok := in.Parameters.(*PutEmailIdentityFeedbackAttributesInput) 4850 _ = input 4851 if !ok { 4852 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4853 } 4854 4855 opPath, opQuery := httpbinding.SplitURI("/v2/email/identities/{EmailIdentity}/feedback") 4856 request.URL.Path = opPath 4857 if len(request.URL.RawQuery) > 0 { 4858 request.URL.RawQuery = "&" + opQuery 4859 } else { 4860 request.URL.RawQuery = opQuery 4861 } 4862 4863 request.Method = "PUT" 4864 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4865 if err != nil { 4866 return out, metadata, &smithy.SerializationError{Err: err} 4867 } 4868 4869 if err := awsRestjson1_serializeOpHttpBindingsPutEmailIdentityFeedbackAttributesInput(input, restEncoder); err != nil { 4870 return out, metadata, &smithy.SerializationError{Err: err} 4871 } 4872 4873 restEncoder.SetHeader("Content-Type").String("application/json") 4874 4875 jsonEncoder := smithyjson.NewEncoder() 4876 if err := awsRestjson1_serializeOpDocumentPutEmailIdentityFeedbackAttributesInput(input, jsonEncoder.Value); err != nil { 4877 return out, metadata, &smithy.SerializationError{Err: err} 4878 } 4879 4880 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4881 return out, metadata, &smithy.SerializationError{Err: err} 4882 } 4883 4884 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4885 return out, metadata, &smithy.SerializationError{Err: err} 4886 } 4887 in.Request = request 4888 4889 return next.HandleSerialize(ctx, in) 4890} 4891func awsRestjson1_serializeOpHttpBindingsPutEmailIdentityFeedbackAttributesInput(v *PutEmailIdentityFeedbackAttributesInput, encoder *httpbinding.Encoder) error { 4892 if v == nil { 4893 return fmt.Errorf("unsupported serialization of nil %T", v) 4894 } 4895 4896 if v.EmailIdentity == nil || len(*v.EmailIdentity) == 0 { 4897 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailIdentity must not be empty")} 4898 } 4899 if v.EmailIdentity != nil { 4900 if err := encoder.SetURI("EmailIdentity").String(*v.EmailIdentity); err != nil { 4901 return err 4902 } 4903 } 4904 4905 return nil 4906} 4907 4908func awsRestjson1_serializeOpDocumentPutEmailIdentityFeedbackAttributesInput(v *PutEmailIdentityFeedbackAttributesInput, value smithyjson.Value) error { 4909 object := value.Object() 4910 defer object.Close() 4911 4912 if v.EmailForwardingEnabled { 4913 ok := object.Key("EmailForwardingEnabled") 4914 ok.Boolean(v.EmailForwardingEnabled) 4915 } 4916 4917 return nil 4918} 4919 4920type awsRestjson1_serializeOpPutEmailIdentityMailFromAttributes struct { 4921} 4922 4923func (*awsRestjson1_serializeOpPutEmailIdentityMailFromAttributes) ID() string { 4924 return "OperationSerializer" 4925} 4926 4927func (m *awsRestjson1_serializeOpPutEmailIdentityMailFromAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 4928 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 4929) { 4930 request, ok := in.Request.(*smithyhttp.Request) 4931 if !ok { 4932 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 4933 } 4934 4935 input, ok := in.Parameters.(*PutEmailIdentityMailFromAttributesInput) 4936 _ = input 4937 if !ok { 4938 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 4939 } 4940 4941 opPath, opQuery := httpbinding.SplitURI("/v2/email/identities/{EmailIdentity}/mail-from") 4942 request.URL.Path = opPath 4943 if len(request.URL.RawQuery) > 0 { 4944 request.URL.RawQuery = "&" + opQuery 4945 } else { 4946 request.URL.RawQuery = opQuery 4947 } 4948 4949 request.Method = "PUT" 4950 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 4951 if err != nil { 4952 return out, metadata, &smithy.SerializationError{Err: err} 4953 } 4954 4955 if err := awsRestjson1_serializeOpHttpBindingsPutEmailIdentityMailFromAttributesInput(input, restEncoder); err != nil { 4956 return out, metadata, &smithy.SerializationError{Err: err} 4957 } 4958 4959 restEncoder.SetHeader("Content-Type").String("application/json") 4960 4961 jsonEncoder := smithyjson.NewEncoder() 4962 if err := awsRestjson1_serializeOpDocumentPutEmailIdentityMailFromAttributesInput(input, jsonEncoder.Value); err != nil { 4963 return out, metadata, &smithy.SerializationError{Err: err} 4964 } 4965 4966 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 4967 return out, metadata, &smithy.SerializationError{Err: err} 4968 } 4969 4970 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 4971 return out, metadata, &smithy.SerializationError{Err: err} 4972 } 4973 in.Request = request 4974 4975 return next.HandleSerialize(ctx, in) 4976} 4977func awsRestjson1_serializeOpHttpBindingsPutEmailIdentityMailFromAttributesInput(v *PutEmailIdentityMailFromAttributesInput, encoder *httpbinding.Encoder) error { 4978 if v == nil { 4979 return fmt.Errorf("unsupported serialization of nil %T", v) 4980 } 4981 4982 if v.EmailIdentity == nil || len(*v.EmailIdentity) == 0 { 4983 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailIdentity must not be empty")} 4984 } 4985 if v.EmailIdentity != nil { 4986 if err := encoder.SetURI("EmailIdentity").String(*v.EmailIdentity); err != nil { 4987 return err 4988 } 4989 } 4990 4991 return nil 4992} 4993 4994func awsRestjson1_serializeOpDocumentPutEmailIdentityMailFromAttributesInput(v *PutEmailIdentityMailFromAttributesInput, value smithyjson.Value) error { 4995 object := value.Object() 4996 defer object.Close() 4997 4998 if len(v.BehaviorOnMxFailure) > 0 { 4999 ok := object.Key("BehaviorOnMxFailure") 5000 ok.String(string(v.BehaviorOnMxFailure)) 5001 } 5002 5003 if v.MailFromDomain != nil { 5004 ok := object.Key("MailFromDomain") 5005 ok.String(*v.MailFromDomain) 5006 } 5007 5008 return nil 5009} 5010 5011type awsRestjson1_serializeOpPutSuppressedDestination struct { 5012} 5013 5014func (*awsRestjson1_serializeOpPutSuppressedDestination) ID() string { 5015 return "OperationSerializer" 5016} 5017 5018func (m *awsRestjson1_serializeOpPutSuppressedDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5019 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5020) { 5021 request, ok := in.Request.(*smithyhttp.Request) 5022 if !ok { 5023 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5024 } 5025 5026 input, ok := in.Parameters.(*PutSuppressedDestinationInput) 5027 _ = input 5028 if !ok { 5029 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5030 } 5031 5032 opPath, opQuery := httpbinding.SplitURI("/v2/email/suppression/addresses") 5033 request.URL.Path = opPath 5034 if len(request.URL.RawQuery) > 0 { 5035 request.URL.RawQuery = "&" + opQuery 5036 } else { 5037 request.URL.RawQuery = opQuery 5038 } 5039 5040 request.Method = "PUT" 5041 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5042 if err != nil { 5043 return out, metadata, &smithy.SerializationError{Err: err} 5044 } 5045 5046 restEncoder.SetHeader("Content-Type").String("application/json") 5047 5048 jsonEncoder := smithyjson.NewEncoder() 5049 if err := awsRestjson1_serializeOpDocumentPutSuppressedDestinationInput(input, jsonEncoder.Value); err != nil { 5050 return out, metadata, &smithy.SerializationError{Err: err} 5051 } 5052 5053 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5054 return out, metadata, &smithy.SerializationError{Err: err} 5055 } 5056 5057 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5058 return out, metadata, &smithy.SerializationError{Err: err} 5059 } 5060 in.Request = request 5061 5062 return next.HandleSerialize(ctx, in) 5063} 5064func awsRestjson1_serializeOpHttpBindingsPutSuppressedDestinationInput(v *PutSuppressedDestinationInput, encoder *httpbinding.Encoder) error { 5065 if v == nil { 5066 return fmt.Errorf("unsupported serialization of nil %T", v) 5067 } 5068 5069 return nil 5070} 5071 5072func awsRestjson1_serializeOpDocumentPutSuppressedDestinationInput(v *PutSuppressedDestinationInput, value smithyjson.Value) error { 5073 object := value.Object() 5074 defer object.Close() 5075 5076 if v.EmailAddress != nil { 5077 ok := object.Key("EmailAddress") 5078 ok.String(*v.EmailAddress) 5079 } 5080 5081 if len(v.Reason) > 0 { 5082 ok := object.Key("Reason") 5083 ok.String(string(v.Reason)) 5084 } 5085 5086 return nil 5087} 5088 5089type awsRestjson1_serializeOpSendBulkEmail struct { 5090} 5091 5092func (*awsRestjson1_serializeOpSendBulkEmail) ID() string { 5093 return "OperationSerializer" 5094} 5095 5096func (m *awsRestjson1_serializeOpSendBulkEmail) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5097 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5098) { 5099 request, ok := in.Request.(*smithyhttp.Request) 5100 if !ok { 5101 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5102 } 5103 5104 input, ok := in.Parameters.(*SendBulkEmailInput) 5105 _ = input 5106 if !ok { 5107 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5108 } 5109 5110 opPath, opQuery := httpbinding.SplitURI("/v2/email/outbound-bulk-emails") 5111 request.URL.Path = opPath 5112 if len(request.URL.RawQuery) > 0 { 5113 request.URL.RawQuery = "&" + opQuery 5114 } else { 5115 request.URL.RawQuery = opQuery 5116 } 5117 5118 request.Method = "POST" 5119 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5120 if err != nil { 5121 return out, metadata, &smithy.SerializationError{Err: err} 5122 } 5123 5124 restEncoder.SetHeader("Content-Type").String("application/json") 5125 5126 jsonEncoder := smithyjson.NewEncoder() 5127 if err := awsRestjson1_serializeOpDocumentSendBulkEmailInput(input, jsonEncoder.Value); err != nil { 5128 return out, metadata, &smithy.SerializationError{Err: err} 5129 } 5130 5131 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5132 return out, metadata, &smithy.SerializationError{Err: err} 5133 } 5134 5135 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5136 return out, metadata, &smithy.SerializationError{Err: err} 5137 } 5138 in.Request = request 5139 5140 return next.HandleSerialize(ctx, in) 5141} 5142func awsRestjson1_serializeOpHttpBindingsSendBulkEmailInput(v *SendBulkEmailInput, encoder *httpbinding.Encoder) error { 5143 if v == nil { 5144 return fmt.Errorf("unsupported serialization of nil %T", v) 5145 } 5146 5147 return nil 5148} 5149 5150func awsRestjson1_serializeOpDocumentSendBulkEmailInput(v *SendBulkEmailInput, value smithyjson.Value) error { 5151 object := value.Object() 5152 defer object.Close() 5153 5154 if v.BulkEmailEntries != nil { 5155 ok := object.Key("BulkEmailEntries") 5156 if err := awsRestjson1_serializeDocumentBulkEmailEntryList(v.BulkEmailEntries, ok); err != nil { 5157 return err 5158 } 5159 } 5160 5161 if v.ConfigurationSetName != nil { 5162 ok := object.Key("ConfigurationSetName") 5163 ok.String(*v.ConfigurationSetName) 5164 } 5165 5166 if v.DefaultContent != nil { 5167 ok := object.Key("DefaultContent") 5168 if err := awsRestjson1_serializeDocumentBulkEmailContent(v.DefaultContent, ok); err != nil { 5169 return err 5170 } 5171 } 5172 5173 if v.DefaultEmailTags != nil { 5174 ok := object.Key("DefaultEmailTags") 5175 if err := awsRestjson1_serializeDocumentMessageTagList(v.DefaultEmailTags, ok); err != nil { 5176 return err 5177 } 5178 } 5179 5180 if v.FeedbackForwardingEmailAddress != nil { 5181 ok := object.Key("FeedbackForwardingEmailAddress") 5182 ok.String(*v.FeedbackForwardingEmailAddress) 5183 } 5184 5185 if v.FeedbackForwardingEmailAddressIdentityArn != nil { 5186 ok := object.Key("FeedbackForwardingEmailAddressIdentityArn") 5187 ok.String(*v.FeedbackForwardingEmailAddressIdentityArn) 5188 } 5189 5190 if v.FromEmailAddress != nil { 5191 ok := object.Key("FromEmailAddress") 5192 ok.String(*v.FromEmailAddress) 5193 } 5194 5195 if v.FromEmailAddressIdentityArn != nil { 5196 ok := object.Key("FromEmailAddressIdentityArn") 5197 ok.String(*v.FromEmailAddressIdentityArn) 5198 } 5199 5200 if v.ReplyToAddresses != nil { 5201 ok := object.Key("ReplyToAddresses") 5202 if err := awsRestjson1_serializeDocumentEmailAddressList(v.ReplyToAddresses, ok); err != nil { 5203 return err 5204 } 5205 } 5206 5207 return nil 5208} 5209 5210type awsRestjson1_serializeOpSendCustomVerificationEmail struct { 5211} 5212 5213func (*awsRestjson1_serializeOpSendCustomVerificationEmail) ID() string { 5214 return "OperationSerializer" 5215} 5216 5217func (m *awsRestjson1_serializeOpSendCustomVerificationEmail) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5218 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5219) { 5220 request, ok := in.Request.(*smithyhttp.Request) 5221 if !ok { 5222 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5223 } 5224 5225 input, ok := in.Parameters.(*SendCustomVerificationEmailInput) 5226 _ = input 5227 if !ok { 5228 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5229 } 5230 5231 opPath, opQuery := httpbinding.SplitURI("/v2/email/outbound-custom-verification-emails") 5232 request.URL.Path = opPath 5233 if len(request.URL.RawQuery) > 0 { 5234 request.URL.RawQuery = "&" + opQuery 5235 } else { 5236 request.URL.RawQuery = opQuery 5237 } 5238 5239 request.Method = "POST" 5240 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5241 if err != nil { 5242 return out, metadata, &smithy.SerializationError{Err: err} 5243 } 5244 5245 restEncoder.SetHeader("Content-Type").String("application/json") 5246 5247 jsonEncoder := smithyjson.NewEncoder() 5248 if err := awsRestjson1_serializeOpDocumentSendCustomVerificationEmailInput(input, jsonEncoder.Value); err != nil { 5249 return out, metadata, &smithy.SerializationError{Err: err} 5250 } 5251 5252 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5253 return out, metadata, &smithy.SerializationError{Err: err} 5254 } 5255 5256 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5257 return out, metadata, &smithy.SerializationError{Err: err} 5258 } 5259 in.Request = request 5260 5261 return next.HandleSerialize(ctx, in) 5262} 5263func awsRestjson1_serializeOpHttpBindingsSendCustomVerificationEmailInput(v *SendCustomVerificationEmailInput, encoder *httpbinding.Encoder) error { 5264 if v == nil { 5265 return fmt.Errorf("unsupported serialization of nil %T", v) 5266 } 5267 5268 return nil 5269} 5270 5271func awsRestjson1_serializeOpDocumentSendCustomVerificationEmailInput(v *SendCustomVerificationEmailInput, value smithyjson.Value) error { 5272 object := value.Object() 5273 defer object.Close() 5274 5275 if v.ConfigurationSetName != nil { 5276 ok := object.Key("ConfigurationSetName") 5277 ok.String(*v.ConfigurationSetName) 5278 } 5279 5280 if v.EmailAddress != nil { 5281 ok := object.Key("EmailAddress") 5282 ok.String(*v.EmailAddress) 5283 } 5284 5285 if v.TemplateName != nil { 5286 ok := object.Key("TemplateName") 5287 ok.String(*v.TemplateName) 5288 } 5289 5290 return nil 5291} 5292 5293type awsRestjson1_serializeOpSendEmail struct { 5294} 5295 5296func (*awsRestjson1_serializeOpSendEmail) ID() string { 5297 return "OperationSerializer" 5298} 5299 5300func (m *awsRestjson1_serializeOpSendEmail) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5301 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5302) { 5303 request, ok := in.Request.(*smithyhttp.Request) 5304 if !ok { 5305 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5306 } 5307 5308 input, ok := in.Parameters.(*SendEmailInput) 5309 _ = input 5310 if !ok { 5311 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5312 } 5313 5314 opPath, opQuery := httpbinding.SplitURI("/v2/email/outbound-emails") 5315 request.URL.Path = opPath 5316 if len(request.URL.RawQuery) > 0 { 5317 request.URL.RawQuery = "&" + opQuery 5318 } else { 5319 request.URL.RawQuery = opQuery 5320 } 5321 5322 request.Method = "POST" 5323 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5324 if err != nil { 5325 return out, metadata, &smithy.SerializationError{Err: err} 5326 } 5327 5328 restEncoder.SetHeader("Content-Type").String("application/json") 5329 5330 jsonEncoder := smithyjson.NewEncoder() 5331 if err := awsRestjson1_serializeOpDocumentSendEmailInput(input, jsonEncoder.Value); err != nil { 5332 return out, metadata, &smithy.SerializationError{Err: err} 5333 } 5334 5335 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5336 return out, metadata, &smithy.SerializationError{Err: err} 5337 } 5338 5339 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5340 return out, metadata, &smithy.SerializationError{Err: err} 5341 } 5342 in.Request = request 5343 5344 return next.HandleSerialize(ctx, in) 5345} 5346func awsRestjson1_serializeOpHttpBindingsSendEmailInput(v *SendEmailInput, encoder *httpbinding.Encoder) error { 5347 if v == nil { 5348 return fmt.Errorf("unsupported serialization of nil %T", v) 5349 } 5350 5351 return nil 5352} 5353 5354func awsRestjson1_serializeOpDocumentSendEmailInput(v *SendEmailInput, value smithyjson.Value) error { 5355 object := value.Object() 5356 defer object.Close() 5357 5358 if v.ConfigurationSetName != nil { 5359 ok := object.Key("ConfigurationSetName") 5360 ok.String(*v.ConfigurationSetName) 5361 } 5362 5363 if v.Content != nil { 5364 ok := object.Key("Content") 5365 if err := awsRestjson1_serializeDocumentEmailContent(v.Content, ok); err != nil { 5366 return err 5367 } 5368 } 5369 5370 if v.Destination != nil { 5371 ok := object.Key("Destination") 5372 if err := awsRestjson1_serializeDocumentDestination(v.Destination, ok); err != nil { 5373 return err 5374 } 5375 } 5376 5377 if v.EmailTags != nil { 5378 ok := object.Key("EmailTags") 5379 if err := awsRestjson1_serializeDocumentMessageTagList(v.EmailTags, ok); err != nil { 5380 return err 5381 } 5382 } 5383 5384 if v.FeedbackForwardingEmailAddress != nil { 5385 ok := object.Key("FeedbackForwardingEmailAddress") 5386 ok.String(*v.FeedbackForwardingEmailAddress) 5387 } 5388 5389 if v.FeedbackForwardingEmailAddressIdentityArn != nil { 5390 ok := object.Key("FeedbackForwardingEmailAddressIdentityArn") 5391 ok.String(*v.FeedbackForwardingEmailAddressIdentityArn) 5392 } 5393 5394 if v.FromEmailAddress != nil { 5395 ok := object.Key("FromEmailAddress") 5396 ok.String(*v.FromEmailAddress) 5397 } 5398 5399 if v.FromEmailAddressIdentityArn != nil { 5400 ok := object.Key("FromEmailAddressIdentityArn") 5401 ok.String(*v.FromEmailAddressIdentityArn) 5402 } 5403 5404 if v.ListManagementOptions != nil { 5405 ok := object.Key("ListManagementOptions") 5406 if err := awsRestjson1_serializeDocumentListManagementOptions(v.ListManagementOptions, ok); err != nil { 5407 return err 5408 } 5409 } 5410 5411 if v.ReplyToAddresses != nil { 5412 ok := object.Key("ReplyToAddresses") 5413 if err := awsRestjson1_serializeDocumentEmailAddressList(v.ReplyToAddresses, ok); err != nil { 5414 return err 5415 } 5416 } 5417 5418 return nil 5419} 5420 5421type awsRestjson1_serializeOpTagResource struct { 5422} 5423 5424func (*awsRestjson1_serializeOpTagResource) ID() string { 5425 return "OperationSerializer" 5426} 5427 5428func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5429 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5430) { 5431 request, ok := in.Request.(*smithyhttp.Request) 5432 if !ok { 5433 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5434 } 5435 5436 input, ok := in.Parameters.(*TagResourceInput) 5437 _ = input 5438 if !ok { 5439 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5440 } 5441 5442 opPath, opQuery := httpbinding.SplitURI("/v2/email/tags") 5443 request.URL.Path = opPath 5444 if len(request.URL.RawQuery) > 0 { 5445 request.URL.RawQuery = "&" + opQuery 5446 } else { 5447 request.URL.RawQuery = opQuery 5448 } 5449 5450 request.Method = "POST" 5451 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5452 if err != nil { 5453 return out, metadata, &smithy.SerializationError{Err: err} 5454 } 5455 5456 restEncoder.SetHeader("Content-Type").String("application/json") 5457 5458 jsonEncoder := smithyjson.NewEncoder() 5459 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 5460 return out, metadata, &smithy.SerializationError{Err: err} 5461 } 5462 5463 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5464 return out, metadata, &smithy.SerializationError{Err: err} 5465 } 5466 5467 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5468 return out, metadata, &smithy.SerializationError{Err: err} 5469 } 5470 in.Request = request 5471 5472 return next.HandleSerialize(ctx, in) 5473} 5474func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 5475 if v == nil { 5476 return fmt.Errorf("unsupported serialization of nil %T", v) 5477 } 5478 5479 return nil 5480} 5481 5482func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 5483 object := value.Object() 5484 defer object.Close() 5485 5486 if v.ResourceArn != nil { 5487 ok := object.Key("ResourceArn") 5488 ok.String(*v.ResourceArn) 5489 } 5490 5491 if v.Tags != nil { 5492 ok := object.Key("Tags") 5493 if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil { 5494 return err 5495 } 5496 } 5497 5498 return nil 5499} 5500 5501type awsRestjson1_serializeOpTestRenderEmailTemplate struct { 5502} 5503 5504func (*awsRestjson1_serializeOpTestRenderEmailTemplate) ID() string { 5505 return "OperationSerializer" 5506} 5507 5508func (m *awsRestjson1_serializeOpTestRenderEmailTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5509 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5510) { 5511 request, ok := in.Request.(*smithyhttp.Request) 5512 if !ok { 5513 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5514 } 5515 5516 input, ok := in.Parameters.(*TestRenderEmailTemplateInput) 5517 _ = input 5518 if !ok { 5519 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5520 } 5521 5522 opPath, opQuery := httpbinding.SplitURI("/v2/email/templates/{TemplateName}/render") 5523 request.URL.Path = opPath 5524 if len(request.URL.RawQuery) > 0 { 5525 request.URL.RawQuery = "&" + opQuery 5526 } else { 5527 request.URL.RawQuery = opQuery 5528 } 5529 5530 request.Method = "POST" 5531 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5532 if err != nil { 5533 return out, metadata, &smithy.SerializationError{Err: err} 5534 } 5535 5536 if err := awsRestjson1_serializeOpHttpBindingsTestRenderEmailTemplateInput(input, restEncoder); err != nil { 5537 return out, metadata, &smithy.SerializationError{Err: err} 5538 } 5539 5540 restEncoder.SetHeader("Content-Type").String("application/json") 5541 5542 jsonEncoder := smithyjson.NewEncoder() 5543 if err := awsRestjson1_serializeOpDocumentTestRenderEmailTemplateInput(input, jsonEncoder.Value); err != nil { 5544 return out, metadata, &smithy.SerializationError{Err: err} 5545 } 5546 5547 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5548 return out, metadata, &smithy.SerializationError{Err: err} 5549 } 5550 5551 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5552 return out, metadata, &smithy.SerializationError{Err: err} 5553 } 5554 in.Request = request 5555 5556 return next.HandleSerialize(ctx, in) 5557} 5558func awsRestjson1_serializeOpHttpBindingsTestRenderEmailTemplateInput(v *TestRenderEmailTemplateInput, encoder *httpbinding.Encoder) error { 5559 if v == nil { 5560 return fmt.Errorf("unsupported serialization of nil %T", v) 5561 } 5562 5563 if v.TemplateName == nil || len(*v.TemplateName) == 0 { 5564 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateName must not be empty")} 5565 } 5566 if v.TemplateName != nil { 5567 if err := encoder.SetURI("TemplateName").String(*v.TemplateName); err != nil { 5568 return err 5569 } 5570 } 5571 5572 return nil 5573} 5574 5575func awsRestjson1_serializeOpDocumentTestRenderEmailTemplateInput(v *TestRenderEmailTemplateInput, value smithyjson.Value) error { 5576 object := value.Object() 5577 defer object.Close() 5578 5579 if v.TemplateData != nil { 5580 ok := object.Key("TemplateData") 5581 ok.String(*v.TemplateData) 5582 } 5583 5584 return nil 5585} 5586 5587type awsRestjson1_serializeOpUntagResource struct { 5588} 5589 5590func (*awsRestjson1_serializeOpUntagResource) ID() string { 5591 return "OperationSerializer" 5592} 5593 5594func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5595 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5596) { 5597 request, ok := in.Request.(*smithyhttp.Request) 5598 if !ok { 5599 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5600 } 5601 5602 input, ok := in.Parameters.(*UntagResourceInput) 5603 _ = input 5604 if !ok { 5605 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5606 } 5607 5608 opPath, opQuery := httpbinding.SplitURI("/v2/email/tags") 5609 request.URL.Path = opPath 5610 if len(request.URL.RawQuery) > 0 { 5611 request.URL.RawQuery = "&" + opQuery 5612 } else { 5613 request.URL.RawQuery = opQuery 5614 } 5615 5616 request.Method = "DELETE" 5617 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5618 if err != nil { 5619 return out, metadata, &smithy.SerializationError{Err: err} 5620 } 5621 5622 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 5623 return out, metadata, &smithy.SerializationError{Err: err} 5624 } 5625 5626 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5627 return out, metadata, &smithy.SerializationError{Err: err} 5628 } 5629 in.Request = request 5630 5631 return next.HandleSerialize(ctx, in) 5632} 5633func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 5634 if v == nil { 5635 return fmt.Errorf("unsupported serialization of nil %T", v) 5636 } 5637 5638 if v.ResourceArn != nil { 5639 encoder.SetQuery("ResourceArn").String(*v.ResourceArn) 5640 } 5641 5642 if v.TagKeys != nil { 5643 for i := range v.TagKeys { 5644 encoder.AddQuery("TagKeys").String(v.TagKeys[i]) 5645 } 5646 } 5647 5648 return nil 5649} 5650 5651type awsRestjson1_serializeOpUpdateConfigurationSetEventDestination struct { 5652} 5653 5654func (*awsRestjson1_serializeOpUpdateConfigurationSetEventDestination) ID() string { 5655 return "OperationSerializer" 5656} 5657 5658func (m *awsRestjson1_serializeOpUpdateConfigurationSetEventDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5659 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5660) { 5661 request, ok := in.Request.(*smithyhttp.Request) 5662 if !ok { 5663 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5664 } 5665 5666 input, ok := in.Parameters.(*UpdateConfigurationSetEventDestinationInput) 5667 _ = input 5668 if !ok { 5669 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5670 } 5671 5672 opPath, opQuery := httpbinding.SplitURI("/v2/email/configuration-sets/{ConfigurationSetName}/event-destinations/{EventDestinationName}") 5673 request.URL.Path = opPath 5674 if len(request.URL.RawQuery) > 0 { 5675 request.URL.RawQuery = "&" + opQuery 5676 } else { 5677 request.URL.RawQuery = opQuery 5678 } 5679 5680 request.Method = "PUT" 5681 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5682 if err != nil { 5683 return out, metadata, &smithy.SerializationError{Err: err} 5684 } 5685 5686 if err := awsRestjson1_serializeOpHttpBindingsUpdateConfigurationSetEventDestinationInput(input, restEncoder); err != nil { 5687 return out, metadata, &smithy.SerializationError{Err: err} 5688 } 5689 5690 restEncoder.SetHeader("Content-Type").String("application/json") 5691 5692 jsonEncoder := smithyjson.NewEncoder() 5693 if err := awsRestjson1_serializeOpDocumentUpdateConfigurationSetEventDestinationInput(input, jsonEncoder.Value); err != nil { 5694 return out, metadata, &smithy.SerializationError{Err: err} 5695 } 5696 5697 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5698 return out, metadata, &smithy.SerializationError{Err: err} 5699 } 5700 5701 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5702 return out, metadata, &smithy.SerializationError{Err: err} 5703 } 5704 in.Request = request 5705 5706 return next.HandleSerialize(ctx, in) 5707} 5708func awsRestjson1_serializeOpHttpBindingsUpdateConfigurationSetEventDestinationInput(v *UpdateConfigurationSetEventDestinationInput, encoder *httpbinding.Encoder) error { 5709 if v == nil { 5710 return fmt.Errorf("unsupported serialization of nil %T", v) 5711 } 5712 5713 if v.ConfigurationSetName == nil || len(*v.ConfigurationSetName) == 0 { 5714 return &smithy.SerializationError{Err: fmt.Errorf("input member ConfigurationSetName must not be empty")} 5715 } 5716 if v.ConfigurationSetName != nil { 5717 if err := encoder.SetURI("ConfigurationSetName").String(*v.ConfigurationSetName); err != nil { 5718 return err 5719 } 5720 } 5721 5722 if v.EventDestinationName == nil || len(*v.EventDestinationName) == 0 { 5723 return &smithy.SerializationError{Err: fmt.Errorf("input member EventDestinationName must not be empty")} 5724 } 5725 if v.EventDestinationName != nil { 5726 if err := encoder.SetURI("EventDestinationName").String(*v.EventDestinationName); err != nil { 5727 return err 5728 } 5729 } 5730 5731 return nil 5732} 5733 5734func awsRestjson1_serializeOpDocumentUpdateConfigurationSetEventDestinationInput(v *UpdateConfigurationSetEventDestinationInput, value smithyjson.Value) error { 5735 object := value.Object() 5736 defer object.Close() 5737 5738 if v.EventDestination != nil { 5739 ok := object.Key("EventDestination") 5740 if err := awsRestjson1_serializeDocumentEventDestinationDefinition(v.EventDestination, ok); err != nil { 5741 return err 5742 } 5743 } 5744 5745 return nil 5746} 5747 5748type awsRestjson1_serializeOpUpdateContact struct { 5749} 5750 5751func (*awsRestjson1_serializeOpUpdateContact) ID() string { 5752 return "OperationSerializer" 5753} 5754 5755func (m *awsRestjson1_serializeOpUpdateContact) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5756 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5757) { 5758 request, ok := in.Request.(*smithyhttp.Request) 5759 if !ok { 5760 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5761 } 5762 5763 input, ok := in.Parameters.(*UpdateContactInput) 5764 _ = input 5765 if !ok { 5766 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5767 } 5768 5769 opPath, opQuery := httpbinding.SplitURI("/v2/email/contact-lists/{ContactListName}/contacts/{EmailAddress}") 5770 request.URL.Path = opPath 5771 if len(request.URL.RawQuery) > 0 { 5772 request.URL.RawQuery = "&" + opQuery 5773 } else { 5774 request.URL.RawQuery = opQuery 5775 } 5776 5777 request.Method = "PUT" 5778 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5779 if err != nil { 5780 return out, metadata, &smithy.SerializationError{Err: err} 5781 } 5782 5783 if err := awsRestjson1_serializeOpHttpBindingsUpdateContactInput(input, restEncoder); err != nil { 5784 return out, metadata, &smithy.SerializationError{Err: err} 5785 } 5786 5787 restEncoder.SetHeader("Content-Type").String("application/json") 5788 5789 jsonEncoder := smithyjson.NewEncoder() 5790 if err := awsRestjson1_serializeOpDocumentUpdateContactInput(input, jsonEncoder.Value); err != nil { 5791 return out, metadata, &smithy.SerializationError{Err: err} 5792 } 5793 5794 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5795 return out, metadata, &smithy.SerializationError{Err: err} 5796 } 5797 5798 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5799 return out, metadata, &smithy.SerializationError{Err: err} 5800 } 5801 in.Request = request 5802 5803 return next.HandleSerialize(ctx, in) 5804} 5805func awsRestjson1_serializeOpHttpBindingsUpdateContactInput(v *UpdateContactInput, encoder *httpbinding.Encoder) error { 5806 if v == nil { 5807 return fmt.Errorf("unsupported serialization of nil %T", v) 5808 } 5809 5810 if v.ContactListName == nil || len(*v.ContactListName) == 0 { 5811 return &smithy.SerializationError{Err: fmt.Errorf("input member ContactListName must not be empty")} 5812 } 5813 if v.ContactListName != nil { 5814 if err := encoder.SetURI("ContactListName").String(*v.ContactListName); err != nil { 5815 return err 5816 } 5817 } 5818 5819 if v.EmailAddress == nil || len(*v.EmailAddress) == 0 { 5820 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailAddress must not be empty")} 5821 } 5822 if v.EmailAddress != nil { 5823 if err := encoder.SetURI("EmailAddress").String(*v.EmailAddress); err != nil { 5824 return err 5825 } 5826 } 5827 5828 return nil 5829} 5830 5831func awsRestjson1_serializeOpDocumentUpdateContactInput(v *UpdateContactInput, value smithyjson.Value) error { 5832 object := value.Object() 5833 defer object.Close() 5834 5835 if v.AttributesData != nil { 5836 ok := object.Key("AttributesData") 5837 ok.String(*v.AttributesData) 5838 } 5839 5840 if v.TopicPreferences != nil { 5841 ok := object.Key("TopicPreferences") 5842 if err := awsRestjson1_serializeDocumentTopicPreferenceList(v.TopicPreferences, ok); err != nil { 5843 return err 5844 } 5845 } 5846 5847 if v.UnsubscribeAll { 5848 ok := object.Key("UnsubscribeAll") 5849 ok.Boolean(v.UnsubscribeAll) 5850 } 5851 5852 return nil 5853} 5854 5855type awsRestjson1_serializeOpUpdateContactList struct { 5856} 5857 5858func (*awsRestjson1_serializeOpUpdateContactList) ID() string { 5859 return "OperationSerializer" 5860} 5861 5862func (m *awsRestjson1_serializeOpUpdateContactList) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5863 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5864) { 5865 request, ok := in.Request.(*smithyhttp.Request) 5866 if !ok { 5867 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5868 } 5869 5870 input, ok := in.Parameters.(*UpdateContactListInput) 5871 _ = input 5872 if !ok { 5873 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5874 } 5875 5876 opPath, opQuery := httpbinding.SplitURI("/v2/email/contact-lists/{ContactListName}") 5877 request.URL.Path = opPath 5878 if len(request.URL.RawQuery) > 0 { 5879 request.URL.RawQuery = "&" + opQuery 5880 } else { 5881 request.URL.RawQuery = opQuery 5882 } 5883 5884 request.Method = "PUT" 5885 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5886 if err != nil { 5887 return out, metadata, &smithy.SerializationError{Err: err} 5888 } 5889 5890 if err := awsRestjson1_serializeOpHttpBindingsUpdateContactListInput(input, restEncoder); err != nil { 5891 return out, metadata, &smithy.SerializationError{Err: err} 5892 } 5893 5894 restEncoder.SetHeader("Content-Type").String("application/json") 5895 5896 jsonEncoder := smithyjson.NewEncoder() 5897 if err := awsRestjson1_serializeOpDocumentUpdateContactListInput(input, jsonEncoder.Value); err != nil { 5898 return out, metadata, &smithy.SerializationError{Err: err} 5899 } 5900 5901 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5902 return out, metadata, &smithy.SerializationError{Err: err} 5903 } 5904 5905 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5906 return out, metadata, &smithy.SerializationError{Err: err} 5907 } 5908 in.Request = request 5909 5910 return next.HandleSerialize(ctx, in) 5911} 5912func awsRestjson1_serializeOpHttpBindingsUpdateContactListInput(v *UpdateContactListInput, encoder *httpbinding.Encoder) error { 5913 if v == nil { 5914 return fmt.Errorf("unsupported serialization of nil %T", v) 5915 } 5916 5917 if v.ContactListName == nil || len(*v.ContactListName) == 0 { 5918 return &smithy.SerializationError{Err: fmt.Errorf("input member ContactListName must not be empty")} 5919 } 5920 if v.ContactListName != nil { 5921 if err := encoder.SetURI("ContactListName").String(*v.ContactListName); err != nil { 5922 return err 5923 } 5924 } 5925 5926 return nil 5927} 5928 5929func awsRestjson1_serializeOpDocumentUpdateContactListInput(v *UpdateContactListInput, value smithyjson.Value) error { 5930 object := value.Object() 5931 defer object.Close() 5932 5933 if v.Description != nil { 5934 ok := object.Key("Description") 5935 ok.String(*v.Description) 5936 } 5937 5938 if v.Topics != nil { 5939 ok := object.Key("Topics") 5940 if err := awsRestjson1_serializeDocumentTopics(v.Topics, ok); err != nil { 5941 return err 5942 } 5943 } 5944 5945 return nil 5946} 5947 5948type awsRestjson1_serializeOpUpdateCustomVerificationEmailTemplate struct { 5949} 5950 5951func (*awsRestjson1_serializeOpUpdateCustomVerificationEmailTemplate) ID() string { 5952 return "OperationSerializer" 5953} 5954 5955func (m *awsRestjson1_serializeOpUpdateCustomVerificationEmailTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 5956 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 5957) { 5958 request, ok := in.Request.(*smithyhttp.Request) 5959 if !ok { 5960 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 5961 } 5962 5963 input, ok := in.Parameters.(*UpdateCustomVerificationEmailTemplateInput) 5964 _ = input 5965 if !ok { 5966 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 5967 } 5968 5969 opPath, opQuery := httpbinding.SplitURI("/v2/email/custom-verification-email-templates/{TemplateName}") 5970 request.URL.Path = opPath 5971 if len(request.URL.RawQuery) > 0 { 5972 request.URL.RawQuery = "&" + opQuery 5973 } else { 5974 request.URL.RawQuery = opQuery 5975 } 5976 5977 request.Method = "PUT" 5978 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 5979 if err != nil { 5980 return out, metadata, &smithy.SerializationError{Err: err} 5981 } 5982 5983 if err := awsRestjson1_serializeOpHttpBindingsUpdateCustomVerificationEmailTemplateInput(input, restEncoder); err != nil { 5984 return out, metadata, &smithy.SerializationError{Err: err} 5985 } 5986 5987 restEncoder.SetHeader("Content-Type").String("application/json") 5988 5989 jsonEncoder := smithyjson.NewEncoder() 5990 if err := awsRestjson1_serializeOpDocumentUpdateCustomVerificationEmailTemplateInput(input, jsonEncoder.Value); err != nil { 5991 return out, metadata, &smithy.SerializationError{Err: err} 5992 } 5993 5994 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 5995 return out, metadata, &smithy.SerializationError{Err: err} 5996 } 5997 5998 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 5999 return out, metadata, &smithy.SerializationError{Err: err} 6000 } 6001 in.Request = request 6002 6003 return next.HandleSerialize(ctx, in) 6004} 6005func awsRestjson1_serializeOpHttpBindingsUpdateCustomVerificationEmailTemplateInput(v *UpdateCustomVerificationEmailTemplateInput, encoder *httpbinding.Encoder) error { 6006 if v == nil { 6007 return fmt.Errorf("unsupported serialization of nil %T", v) 6008 } 6009 6010 if v.TemplateName == nil || len(*v.TemplateName) == 0 { 6011 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateName must not be empty")} 6012 } 6013 if v.TemplateName != nil { 6014 if err := encoder.SetURI("TemplateName").String(*v.TemplateName); err != nil { 6015 return err 6016 } 6017 } 6018 6019 return nil 6020} 6021 6022func awsRestjson1_serializeOpDocumentUpdateCustomVerificationEmailTemplateInput(v *UpdateCustomVerificationEmailTemplateInput, value smithyjson.Value) error { 6023 object := value.Object() 6024 defer object.Close() 6025 6026 if v.FailureRedirectionURL != nil { 6027 ok := object.Key("FailureRedirectionURL") 6028 ok.String(*v.FailureRedirectionURL) 6029 } 6030 6031 if v.FromEmailAddress != nil { 6032 ok := object.Key("FromEmailAddress") 6033 ok.String(*v.FromEmailAddress) 6034 } 6035 6036 if v.SuccessRedirectionURL != nil { 6037 ok := object.Key("SuccessRedirectionURL") 6038 ok.String(*v.SuccessRedirectionURL) 6039 } 6040 6041 if v.TemplateContent != nil { 6042 ok := object.Key("TemplateContent") 6043 ok.String(*v.TemplateContent) 6044 } 6045 6046 if v.TemplateSubject != nil { 6047 ok := object.Key("TemplateSubject") 6048 ok.String(*v.TemplateSubject) 6049 } 6050 6051 return nil 6052} 6053 6054type awsRestjson1_serializeOpUpdateEmailIdentityPolicy struct { 6055} 6056 6057func (*awsRestjson1_serializeOpUpdateEmailIdentityPolicy) ID() string { 6058 return "OperationSerializer" 6059} 6060 6061func (m *awsRestjson1_serializeOpUpdateEmailIdentityPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6062 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6063) { 6064 request, ok := in.Request.(*smithyhttp.Request) 6065 if !ok { 6066 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6067 } 6068 6069 input, ok := in.Parameters.(*UpdateEmailIdentityPolicyInput) 6070 _ = input 6071 if !ok { 6072 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6073 } 6074 6075 opPath, opQuery := httpbinding.SplitURI("/v2/email/identities/{EmailIdentity}/policies/{PolicyName}") 6076 request.URL.Path = opPath 6077 if len(request.URL.RawQuery) > 0 { 6078 request.URL.RawQuery = "&" + opQuery 6079 } else { 6080 request.URL.RawQuery = opQuery 6081 } 6082 6083 request.Method = "PUT" 6084 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6085 if err != nil { 6086 return out, metadata, &smithy.SerializationError{Err: err} 6087 } 6088 6089 if err := awsRestjson1_serializeOpHttpBindingsUpdateEmailIdentityPolicyInput(input, restEncoder); err != nil { 6090 return out, metadata, &smithy.SerializationError{Err: err} 6091 } 6092 6093 restEncoder.SetHeader("Content-Type").String("application/json") 6094 6095 jsonEncoder := smithyjson.NewEncoder() 6096 if err := awsRestjson1_serializeOpDocumentUpdateEmailIdentityPolicyInput(input, jsonEncoder.Value); err != nil { 6097 return out, metadata, &smithy.SerializationError{Err: err} 6098 } 6099 6100 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6101 return out, metadata, &smithy.SerializationError{Err: err} 6102 } 6103 6104 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6105 return out, metadata, &smithy.SerializationError{Err: err} 6106 } 6107 in.Request = request 6108 6109 return next.HandleSerialize(ctx, in) 6110} 6111func awsRestjson1_serializeOpHttpBindingsUpdateEmailIdentityPolicyInput(v *UpdateEmailIdentityPolicyInput, encoder *httpbinding.Encoder) error { 6112 if v == nil { 6113 return fmt.Errorf("unsupported serialization of nil %T", v) 6114 } 6115 6116 if v.EmailIdentity == nil || len(*v.EmailIdentity) == 0 { 6117 return &smithy.SerializationError{Err: fmt.Errorf("input member EmailIdentity must not be empty")} 6118 } 6119 if v.EmailIdentity != nil { 6120 if err := encoder.SetURI("EmailIdentity").String(*v.EmailIdentity); err != nil { 6121 return err 6122 } 6123 } 6124 6125 if v.PolicyName == nil || len(*v.PolicyName) == 0 { 6126 return &smithy.SerializationError{Err: fmt.Errorf("input member PolicyName must not be empty")} 6127 } 6128 if v.PolicyName != nil { 6129 if err := encoder.SetURI("PolicyName").String(*v.PolicyName); err != nil { 6130 return err 6131 } 6132 } 6133 6134 return nil 6135} 6136 6137func awsRestjson1_serializeOpDocumentUpdateEmailIdentityPolicyInput(v *UpdateEmailIdentityPolicyInput, value smithyjson.Value) error { 6138 object := value.Object() 6139 defer object.Close() 6140 6141 if v.Policy != nil { 6142 ok := object.Key("Policy") 6143 ok.String(*v.Policy) 6144 } 6145 6146 return nil 6147} 6148 6149type awsRestjson1_serializeOpUpdateEmailTemplate struct { 6150} 6151 6152func (*awsRestjson1_serializeOpUpdateEmailTemplate) ID() string { 6153 return "OperationSerializer" 6154} 6155 6156func (m *awsRestjson1_serializeOpUpdateEmailTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 6157 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 6158) { 6159 request, ok := in.Request.(*smithyhttp.Request) 6160 if !ok { 6161 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 6162 } 6163 6164 input, ok := in.Parameters.(*UpdateEmailTemplateInput) 6165 _ = input 6166 if !ok { 6167 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 6168 } 6169 6170 opPath, opQuery := httpbinding.SplitURI("/v2/email/templates/{TemplateName}") 6171 request.URL.Path = opPath 6172 if len(request.URL.RawQuery) > 0 { 6173 request.URL.RawQuery = "&" + opQuery 6174 } else { 6175 request.URL.RawQuery = opQuery 6176 } 6177 6178 request.Method = "PUT" 6179 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 6180 if err != nil { 6181 return out, metadata, &smithy.SerializationError{Err: err} 6182 } 6183 6184 if err := awsRestjson1_serializeOpHttpBindingsUpdateEmailTemplateInput(input, restEncoder); err != nil { 6185 return out, metadata, &smithy.SerializationError{Err: err} 6186 } 6187 6188 restEncoder.SetHeader("Content-Type").String("application/json") 6189 6190 jsonEncoder := smithyjson.NewEncoder() 6191 if err := awsRestjson1_serializeOpDocumentUpdateEmailTemplateInput(input, jsonEncoder.Value); err != nil { 6192 return out, metadata, &smithy.SerializationError{Err: err} 6193 } 6194 6195 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 6196 return out, metadata, &smithy.SerializationError{Err: err} 6197 } 6198 6199 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 6200 return out, metadata, &smithy.SerializationError{Err: err} 6201 } 6202 in.Request = request 6203 6204 return next.HandleSerialize(ctx, in) 6205} 6206func awsRestjson1_serializeOpHttpBindingsUpdateEmailTemplateInput(v *UpdateEmailTemplateInput, encoder *httpbinding.Encoder) error { 6207 if v == nil { 6208 return fmt.Errorf("unsupported serialization of nil %T", v) 6209 } 6210 6211 if v.TemplateName == nil || len(*v.TemplateName) == 0 { 6212 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateName must not be empty")} 6213 } 6214 if v.TemplateName != nil { 6215 if err := encoder.SetURI("TemplateName").String(*v.TemplateName); err != nil { 6216 return err 6217 } 6218 } 6219 6220 return nil 6221} 6222 6223func awsRestjson1_serializeOpDocumentUpdateEmailTemplateInput(v *UpdateEmailTemplateInput, value smithyjson.Value) error { 6224 object := value.Object() 6225 defer object.Close() 6226 6227 if v.TemplateContent != nil { 6228 ok := object.Key("TemplateContent") 6229 if err := awsRestjson1_serializeDocumentEmailTemplateContent(v.TemplateContent, ok); err != nil { 6230 return err 6231 } 6232 } 6233 6234 return nil 6235} 6236 6237func awsRestjson1_serializeDocumentAdditionalContactEmailAddresses(v []string, value smithyjson.Value) error { 6238 array := value.Array() 6239 defer array.Close() 6240 6241 for i := range v { 6242 av := array.Value() 6243 av.String(v[i]) 6244 } 6245 return nil 6246} 6247 6248func awsRestjson1_serializeDocumentBody(v *types.Body, value smithyjson.Value) error { 6249 object := value.Object() 6250 defer object.Close() 6251 6252 if v.Html != nil { 6253 ok := object.Key("Html") 6254 if err := awsRestjson1_serializeDocumentContent(v.Html, ok); err != nil { 6255 return err 6256 } 6257 } 6258 6259 if v.Text != nil { 6260 ok := object.Key("Text") 6261 if err := awsRestjson1_serializeDocumentContent(v.Text, ok); err != nil { 6262 return err 6263 } 6264 } 6265 6266 return nil 6267} 6268 6269func awsRestjson1_serializeDocumentBulkEmailContent(v *types.BulkEmailContent, value smithyjson.Value) error { 6270 object := value.Object() 6271 defer object.Close() 6272 6273 if v.Template != nil { 6274 ok := object.Key("Template") 6275 if err := awsRestjson1_serializeDocumentTemplate(v.Template, ok); err != nil { 6276 return err 6277 } 6278 } 6279 6280 return nil 6281} 6282 6283func awsRestjson1_serializeDocumentBulkEmailEntry(v *types.BulkEmailEntry, value smithyjson.Value) error { 6284 object := value.Object() 6285 defer object.Close() 6286 6287 if v.Destination != nil { 6288 ok := object.Key("Destination") 6289 if err := awsRestjson1_serializeDocumentDestination(v.Destination, ok); err != nil { 6290 return err 6291 } 6292 } 6293 6294 if v.ReplacementEmailContent != nil { 6295 ok := object.Key("ReplacementEmailContent") 6296 if err := awsRestjson1_serializeDocumentReplacementEmailContent(v.ReplacementEmailContent, ok); err != nil { 6297 return err 6298 } 6299 } 6300 6301 if v.ReplacementTags != nil { 6302 ok := object.Key("ReplacementTags") 6303 if err := awsRestjson1_serializeDocumentMessageTagList(v.ReplacementTags, ok); err != nil { 6304 return err 6305 } 6306 } 6307 6308 return nil 6309} 6310 6311func awsRestjson1_serializeDocumentBulkEmailEntryList(v []types.BulkEmailEntry, value smithyjson.Value) error { 6312 array := value.Array() 6313 defer array.Close() 6314 6315 for i := range v { 6316 av := array.Value() 6317 if err := awsRestjson1_serializeDocumentBulkEmailEntry(&v[i], av); err != nil { 6318 return err 6319 } 6320 } 6321 return nil 6322} 6323 6324func awsRestjson1_serializeDocumentCloudWatchDestination(v *types.CloudWatchDestination, value smithyjson.Value) error { 6325 object := value.Object() 6326 defer object.Close() 6327 6328 if v.DimensionConfigurations != nil { 6329 ok := object.Key("DimensionConfigurations") 6330 if err := awsRestjson1_serializeDocumentCloudWatchDimensionConfigurations(v.DimensionConfigurations, ok); err != nil { 6331 return err 6332 } 6333 } 6334 6335 return nil 6336} 6337 6338func awsRestjson1_serializeDocumentCloudWatchDimensionConfiguration(v *types.CloudWatchDimensionConfiguration, value smithyjson.Value) error { 6339 object := value.Object() 6340 defer object.Close() 6341 6342 if v.DefaultDimensionValue != nil { 6343 ok := object.Key("DefaultDimensionValue") 6344 ok.String(*v.DefaultDimensionValue) 6345 } 6346 6347 if v.DimensionName != nil { 6348 ok := object.Key("DimensionName") 6349 ok.String(*v.DimensionName) 6350 } 6351 6352 if len(v.DimensionValueSource) > 0 { 6353 ok := object.Key("DimensionValueSource") 6354 ok.String(string(v.DimensionValueSource)) 6355 } 6356 6357 return nil 6358} 6359 6360func awsRestjson1_serializeDocumentCloudWatchDimensionConfigurations(v []types.CloudWatchDimensionConfiguration, value smithyjson.Value) error { 6361 array := value.Array() 6362 defer array.Close() 6363 6364 for i := range v { 6365 av := array.Value() 6366 if err := awsRestjson1_serializeDocumentCloudWatchDimensionConfiguration(&v[i], av); err != nil { 6367 return err 6368 } 6369 } 6370 return nil 6371} 6372 6373func awsRestjson1_serializeDocumentContactListDestination(v *types.ContactListDestination, value smithyjson.Value) error { 6374 object := value.Object() 6375 defer object.Close() 6376 6377 if len(v.ContactListImportAction) > 0 { 6378 ok := object.Key("ContactListImportAction") 6379 ok.String(string(v.ContactListImportAction)) 6380 } 6381 6382 if v.ContactListName != nil { 6383 ok := object.Key("ContactListName") 6384 ok.String(*v.ContactListName) 6385 } 6386 6387 return nil 6388} 6389 6390func awsRestjson1_serializeDocumentContent(v *types.Content, value smithyjson.Value) error { 6391 object := value.Object() 6392 defer object.Close() 6393 6394 if v.Charset != nil { 6395 ok := object.Key("Charset") 6396 ok.String(*v.Charset) 6397 } 6398 6399 if v.Data != nil { 6400 ok := object.Key("Data") 6401 ok.String(*v.Data) 6402 } 6403 6404 return nil 6405} 6406 6407func awsRestjson1_serializeDocumentDeliveryOptions(v *types.DeliveryOptions, value smithyjson.Value) error { 6408 object := value.Object() 6409 defer object.Close() 6410 6411 if v.SendingPoolName != nil { 6412 ok := object.Key("SendingPoolName") 6413 ok.String(*v.SendingPoolName) 6414 } 6415 6416 if len(v.TlsPolicy) > 0 { 6417 ok := object.Key("TlsPolicy") 6418 ok.String(string(v.TlsPolicy)) 6419 } 6420 6421 return nil 6422} 6423 6424func awsRestjson1_serializeDocumentDestination(v *types.Destination, value smithyjson.Value) error { 6425 object := value.Object() 6426 defer object.Close() 6427 6428 if v.BccAddresses != nil { 6429 ok := object.Key("BccAddresses") 6430 if err := awsRestjson1_serializeDocumentEmailAddressList(v.BccAddresses, ok); err != nil { 6431 return err 6432 } 6433 } 6434 6435 if v.CcAddresses != nil { 6436 ok := object.Key("CcAddresses") 6437 if err := awsRestjson1_serializeDocumentEmailAddressList(v.CcAddresses, ok); err != nil { 6438 return err 6439 } 6440 } 6441 6442 if v.ToAddresses != nil { 6443 ok := object.Key("ToAddresses") 6444 if err := awsRestjson1_serializeDocumentEmailAddressList(v.ToAddresses, ok); err != nil { 6445 return err 6446 } 6447 } 6448 6449 return nil 6450} 6451 6452func awsRestjson1_serializeDocumentDkimSigningAttributes(v *types.DkimSigningAttributes, value smithyjson.Value) error { 6453 object := value.Object() 6454 defer object.Close() 6455 6456 if v.DomainSigningPrivateKey != nil { 6457 ok := object.Key("DomainSigningPrivateKey") 6458 ok.String(*v.DomainSigningPrivateKey) 6459 } 6460 6461 if v.DomainSigningSelector != nil { 6462 ok := object.Key("DomainSigningSelector") 6463 ok.String(*v.DomainSigningSelector) 6464 } 6465 6466 return nil 6467} 6468 6469func awsRestjson1_serializeDocumentDomainDeliverabilityTrackingOption(v *types.DomainDeliverabilityTrackingOption, value smithyjson.Value) error { 6470 object := value.Object() 6471 defer object.Close() 6472 6473 if v.Domain != nil { 6474 ok := object.Key("Domain") 6475 ok.String(*v.Domain) 6476 } 6477 6478 if v.InboxPlacementTrackingOption != nil { 6479 ok := object.Key("InboxPlacementTrackingOption") 6480 if err := awsRestjson1_serializeDocumentInboxPlacementTrackingOption(v.InboxPlacementTrackingOption, ok); err != nil { 6481 return err 6482 } 6483 } 6484 6485 if v.SubscriptionStartDate != nil { 6486 ok := object.Key("SubscriptionStartDate") 6487 ok.Double(smithytime.FormatEpochSeconds(*v.SubscriptionStartDate)) 6488 } 6489 6490 return nil 6491} 6492 6493func awsRestjson1_serializeDocumentDomainDeliverabilityTrackingOptions(v []types.DomainDeliverabilityTrackingOption, value smithyjson.Value) error { 6494 array := value.Array() 6495 defer array.Close() 6496 6497 for i := range v { 6498 av := array.Value() 6499 if err := awsRestjson1_serializeDocumentDomainDeliverabilityTrackingOption(&v[i], av); err != nil { 6500 return err 6501 } 6502 } 6503 return nil 6504} 6505 6506func awsRestjson1_serializeDocumentEmailAddressList(v []string, value smithyjson.Value) error { 6507 array := value.Array() 6508 defer array.Close() 6509 6510 for i := range v { 6511 av := array.Value() 6512 av.String(v[i]) 6513 } 6514 return nil 6515} 6516 6517func awsRestjson1_serializeDocumentEmailContent(v *types.EmailContent, value smithyjson.Value) error { 6518 object := value.Object() 6519 defer object.Close() 6520 6521 if v.Raw != nil { 6522 ok := object.Key("Raw") 6523 if err := awsRestjson1_serializeDocumentRawMessage(v.Raw, ok); err != nil { 6524 return err 6525 } 6526 } 6527 6528 if v.Simple != nil { 6529 ok := object.Key("Simple") 6530 if err := awsRestjson1_serializeDocumentMessage(v.Simple, ok); err != nil { 6531 return err 6532 } 6533 } 6534 6535 if v.Template != nil { 6536 ok := object.Key("Template") 6537 if err := awsRestjson1_serializeDocumentTemplate(v.Template, ok); err != nil { 6538 return err 6539 } 6540 } 6541 6542 return nil 6543} 6544 6545func awsRestjson1_serializeDocumentEmailTemplateContent(v *types.EmailTemplateContent, value smithyjson.Value) error { 6546 object := value.Object() 6547 defer object.Close() 6548 6549 if v.Html != nil { 6550 ok := object.Key("Html") 6551 ok.String(*v.Html) 6552 } 6553 6554 if v.Subject != nil { 6555 ok := object.Key("Subject") 6556 ok.String(*v.Subject) 6557 } 6558 6559 if v.Text != nil { 6560 ok := object.Key("Text") 6561 ok.String(*v.Text) 6562 } 6563 6564 return nil 6565} 6566 6567func awsRestjson1_serializeDocumentEventDestinationDefinition(v *types.EventDestinationDefinition, value smithyjson.Value) error { 6568 object := value.Object() 6569 defer object.Close() 6570 6571 if v.CloudWatchDestination != nil { 6572 ok := object.Key("CloudWatchDestination") 6573 if err := awsRestjson1_serializeDocumentCloudWatchDestination(v.CloudWatchDestination, ok); err != nil { 6574 return err 6575 } 6576 } 6577 6578 if v.Enabled { 6579 ok := object.Key("Enabled") 6580 ok.Boolean(v.Enabled) 6581 } 6582 6583 if v.KinesisFirehoseDestination != nil { 6584 ok := object.Key("KinesisFirehoseDestination") 6585 if err := awsRestjson1_serializeDocumentKinesisFirehoseDestination(v.KinesisFirehoseDestination, ok); err != nil { 6586 return err 6587 } 6588 } 6589 6590 if v.MatchingEventTypes != nil { 6591 ok := object.Key("MatchingEventTypes") 6592 if err := awsRestjson1_serializeDocumentEventTypes(v.MatchingEventTypes, ok); err != nil { 6593 return err 6594 } 6595 } 6596 6597 if v.PinpointDestination != nil { 6598 ok := object.Key("PinpointDestination") 6599 if err := awsRestjson1_serializeDocumentPinpointDestination(v.PinpointDestination, ok); err != nil { 6600 return err 6601 } 6602 } 6603 6604 if v.SnsDestination != nil { 6605 ok := object.Key("SnsDestination") 6606 if err := awsRestjson1_serializeDocumentSnsDestination(v.SnsDestination, ok); err != nil { 6607 return err 6608 } 6609 } 6610 6611 return nil 6612} 6613 6614func awsRestjson1_serializeDocumentEventTypes(v []types.EventType, value smithyjson.Value) error { 6615 array := value.Array() 6616 defer array.Close() 6617 6618 for i := range v { 6619 av := array.Value() 6620 av.String(string(v[i])) 6621 } 6622 return nil 6623} 6624 6625func awsRestjson1_serializeDocumentImportDataSource(v *types.ImportDataSource, value smithyjson.Value) error { 6626 object := value.Object() 6627 defer object.Close() 6628 6629 if len(v.DataFormat) > 0 { 6630 ok := object.Key("DataFormat") 6631 ok.String(string(v.DataFormat)) 6632 } 6633 6634 if v.S3Url != nil { 6635 ok := object.Key("S3Url") 6636 ok.String(*v.S3Url) 6637 } 6638 6639 return nil 6640} 6641 6642func awsRestjson1_serializeDocumentImportDestination(v *types.ImportDestination, value smithyjson.Value) error { 6643 object := value.Object() 6644 defer object.Close() 6645 6646 if v.ContactListDestination != nil { 6647 ok := object.Key("ContactListDestination") 6648 if err := awsRestjson1_serializeDocumentContactListDestination(v.ContactListDestination, ok); err != nil { 6649 return err 6650 } 6651 } 6652 6653 if v.SuppressionListDestination != nil { 6654 ok := object.Key("SuppressionListDestination") 6655 if err := awsRestjson1_serializeDocumentSuppressionListDestination(v.SuppressionListDestination, ok); err != nil { 6656 return err 6657 } 6658 } 6659 6660 return nil 6661} 6662 6663func awsRestjson1_serializeDocumentInboxPlacementTrackingOption(v *types.InboxPlacementTrackingOption, value smithyjson.Value) error { 6664 object := value.Object() 6665 defer object.Close() 6666 6667 if v.Global { 6668 ok := object.Key("Global") 6669 ok.Boolean(v.Global) 6670 } 6671 6672 if v.TrackedIsps != nil { 6673 ok := object.Key("TrackedIsps") 6674 if err := awsRestjson1_serializeDocumentIspNameList(v.TrackedIsps, ok); err != nil { 6675 return err 6676 } 6677 } 6678 6679 return nil 6680} 6681 6682func awsRestjson1_serializeDocumentIspNameList(v []string, value smithyjson.Value) error { 6683 array := value.Array() 6684 defer array.Close() 6685 6686 for i := range v { 6687 av := array.Value() 6688 av.String(v[i]) 6689 } 6690 return nil 6691} 6692 6693func awsRestjson1_serializeDocumentKinesisFirehoseDestination(v *types.KinesisFirehoseDestination, value smithyjson.Value) error { 6694 object := value.Object() 6695 defer object.Close() 6696 6697 if v.DeliveryStreamArn != nil { 6698 ok := object.Key("DeliveryStreamArn") 6699 ok.String(*v.DeliveryStreamArn) 6700 } 6701 6702 if v.IamRoleArn != nil { 6703 ok := object.Key("IamRoleArn") 6704 ok.String(*v.IamRoleArn) 6705 } 6706 6707 return nil 6708} 6709 6710func awsRestjson1_serializeDocumentListContactsFilter(v *types.ListContactsFilter, value smithyjson.Value) error { 6711 object := value.Object() 6712 defer object.Close() 6713 6714 if len(v.FilteredStatus) > 0 { 6715 ok := object.Key("FilteredStatus") 6716 ok.String(string(v.FilteredStatus)) 6717 } 6718 6719 if v.TopicFilter != nil { 6720 ok := object.Key("TopicFilter") 6721 if err := awsRestjson1_serializeDocumentTopicFilter(v.TopicFilter, ok); err != nil { 6722 return err 6723 } 6724 } 6725 6726 return nil 6727} 6728 6729func awsRestjson1_serializeDocumentListManagementOptions(v *types.ListManagementOptions, value smithyjson.Value) error { 6730 object := value.Object() 6731 defer object.Close() 6732 6733 if v.ContactListName != nil { 6734 ok := object.Key("ContactListName") 6735 ok.String(*v.ContactListName) 6736 } 6737 6738 if v.TopicName != nil { 6739 ok := object.Key("TopicName") 6740 ok.String(*v.TopicName) 6741 } 6742 6743 return nil 6744} 6745 6746func awsRestjson1_serializeDocumentMessage(v *types.Message, value smithyjson.Value) error { 6747 object := value.Object() 6748 defer object.Close() 6749 6750 if v.Body != nil { 6751 ok := object.Key("Body") 6752 if err := awsRestjson1_serializeDocumentBody(v.Body, ok); err != nil { 6753 return err 6754 } 6755 } 6756 6757 if v.Subject != nil { 6758 ok := object.Key("Subject") 6759 if err := awsRestjson1_serializeDocumentContent(v.Subject, ok); err != nil { 6760 return err 6761 } 6762 } 6763 6764 return nil 6765} 6766 6767func awsRestjson1_serializeDocumentMessageTag(v *types.MessageTag, value smithyjson.Value) error { 6768 object := value.Object() 6769 defer object.Close() 6770 6771 if v.Name != nil { 6772 ok := object.Key("Name") 6773 ok.String(*v.Name) 6774 } 6775 6776 if v.Value != nil { 6777 ok := object.Key("Value") 6778 ok.String(*v.Value) 6779 } 6780 6781 return nil 6782} 6783 6784func awsRestjson1_serializeDocumentMessageTagList(v []types.MessageTag, value smithyjson.Value) error { 6785 array := value.Array() 6786 defer array.Close() 6787 6788 for i := range v { 6789 av := array.Value() 6790 if err := awsRestjson1_serializeDocumentMessageTag(&v[i], av); err != nil { 6791 return err 6792 } 6793 } 6794 return nil 6795} 6796 6797func awsRestjson1_serializeDocumentPinpointDestination(v *types.PinpointDestination, value smithyjson.Value) error { 6798 object := value.Object() 6799 defer object.Close() 6800 6801 if v.ApplicationArn != nil { 6802 ok := object.Key("ApplicationArn") 6803 ok.String(*v.ApplicationArn) 6804 } 6805 6806 return nil 6807} 6808 6809func awsRestjson1_serializeDocumentRawMessage(v *types.RawMessage, value smithyjson.Value) error { 6810 object := value.Object() 6811 defer object.Close() 6812 6813 if v.Data != nil { 6814 ok := object.Key("Data") 6815 ok.Base64EncodeBytes(v.Data) 6816 } 6817 6818 return nil 6819} 6820 6821func awsRestjson1_serializeDocumentReplacementEmailContent(v *types.ReplacementEmailContent, value smithyjson.Value) error { 6822 object := value.Object() 6823 defer object.Close() 6824 6825 if v.ReplacementTemplate != nil { 6826 ok := object.Key("ReplacementTemplate") 6827 if err := awsRestjson1_serializeDocumentReplacementTemplate(v.ReplacementTemplate, ok); err != nil { 6828 return err 6829 } 6830 } 6831 6832 return nil 6833} 6834 6835func awsRestjson1_serializeDocumentReplacementTemplate(v *types.ReplacementTemplate, value smithyjson.Value) error { 6836 object := value.Object() 6837 defer object.Close() 6838 6839 if v.ReplacementTemplateData != nil { 6840 ok := object.Key("ReplacementTemplateData") 6841 ok.String(*v.ReplacementTemplateData) 6842 } 6843 6844 return nil 6845} 6846 6847func awsRestjson1_serializeDocumentReputationOptions(v *types.ReputationOptions, value smithyjson.Value) error { 6848 object := value.Object() 6849 defer object.Close() 6850 6851 if v.LastFreshStart != nil { 6852 ok := object.Key("LastFreshStart") 6853 ok.Double(smithytime.FormatEpochSeconds(*v.LastFreshStart)) 6854 } 6855 6856 if v.ReputationMetricsEnabled { 6857 ok := object.Key("ReputationMetricsEnabled") 6858 ok.Boolean(v.ReputationMetricsEnabled) 6859 } 6860 6861 return nil 6862} 6863 6864func awsRestjson1_serializeDocumentSendingOptions(v *types.SendingOptions, value smithyjson.Value) error { 6865 object := value.Object() 6866 defer object.Close() 6867 6868 if v.SendingEnabled { 6869 ok := object.Key("SendingEnabled") 6870 ok.Boolean(v.SendingEnabled) 6871 } 6872 6873 return nil 6874} 6875 6876func awsRestjson1_serializeDocumentSnsDestination(v *types.SnsDestination, value smithyjson.Value) error { 6877 object := value.Object() 6878 defer object.Close() 6879 6880 if v.TopicArn != nil { 6881 ok := object.Key("TopicArn") 6882 ok.String(*v.TopicArn) 6883 } 6884 6885 return nil 6886} 6887 6888func awsRestjson1_serializeDocumentSuppressionListDestination(v *types.SuppressionListDestination, value smithyjson.Value) error { 6889 object := value.Object() 6890 defer object.Close() 6891 6892 if len(v.SuppressionListImportAction) > 0 { 6893 ok := object.Key("SuppressionListImportAction") 6894 ok.String(string(v.SuppressionListImportAction)) 6895 } 6896 6897 return nil 6898} 6899 6900func awsRestjson1_serializeDocumentSuppressionListReasons(v []types.SuppressionListReason, value smithyjson.Value) error { 6901 array := value.Array() 6902 defer array.Close() 6903 6904 for i := range v { 6905 av := array.Value() 6906 av.String(string(v[i])) 6907 } 6908 return nil 6909} 6910 6911func awsRestjson1_serializeDocumentSuppressionOptions(v *types.SuppressionOptions, value smithyjson.Value) error { 6912 object := value.Object() 6913 defer object.Close() 6914 6915 if v.SuppressedReasons != nil { 6916 ok := object.Key("SuppressedReasons") 6917 if err := awsRestjson1_serializeDocumentSuppressionListReasons(v.SuppressedReasons, ok); err != nil { 6918 return err 6919 } 6920 } 6921 6922 return nil 6923} 6924 6925func awsRestjson1_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error { 6926 object := value.Object() 6927 defer object.Close() 6928 6929 if v.Key != nil { 6930 ok := object.Key("Key") 6931 ok.String(*v.Key) 6932 } 6933 6934 if v.Value != nil { 6935 ok := object.Key("Value") 6936 ok.String(*v.Value) 6937 } 6938 6939 return nil 6940} 6941 6942func awsRestjson1_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error { 6943 array := value.Array() 6944 defer array.Close() 6945 6946 for i := range v { 6947 av := array.Value() 6948 if err := awsRestjson1_serializeDocumentTag(&v[i], av); err != nil { 6949 return err 6950 } 6951 } 6952 return nil 6953} 6954 6955func awsRestjson1_serializeDocumentTemplate(v *types.Template, value smithyjson.Value) error { 6956 object := value.Object() 6957 defer object.Close() 6958 6959 if v.TemplateArn != nil { 6960 ok := object.Key("TemplateArn") 6961 ok.String(*v.TemplateArn) 6962 } 6963 6964 if v.TemplateData != nil { 6965 ok := object.Key("TemplateData") 6966 ok.String(*v.TemplateData) 6967 } 6968 6969 if v.TemplateName != nil { 6970 ok := object.Key("TemplateName") 6971 ok.String(*v.TemplateName) 6972 } 6973 6974 return nil 6975} 6976 6977func awsRestjson1_serializeDocumentTopic(v *types.Topic, value smithyjson.Value) error { 6978 object := value.Object() 6979 defer object.Close() 6980 6981 if len(v.DefaultSubscriptionStatus) > 0 { 6982 ok := object.Key("DefaultSubscriptionStatus") 6983 ok.String(string(v.DefaultSubscriptionStatus)) 6984 } 6985 6986 if v.Description != nil { 6987 ok := object.Key("Description") 6988 ok.String(*v.Description) 6989 } 6990 6991 if v.DisplayName != nil { 6992 ok := object.Key("DisplayName") 6993 ok.String(*v.DisplayName) 6994 } 6995 6996 if v.TopicName != nil { 6997 ok := object.Key("TopicName") 6998 ok.String(*v.TopicName) 6999 } 7000 7001 return nil 7002} 7003 7004func awsRestjson1_serializeDocumentTopicFilter(v *types.TopicFilter, value smithyjson.Value) error { 7005 object := value.Object() 7006 defer object.Close() 7007 7008 if v.TopicName != nil { 7009 ok := object.Key("TopicName") 7010 ok.String(*v.TopicName) 7011 } 7012 7013 if v.UseDefaultIfPreferenceUnavailable { 7014 ok := object.Key("UseDefaultIfPreferenceUnavailable") 7015 ok.Boolean(v.UseDefaultIfPreferenceUnavailable) 7016 } 7017 7018 return nil 7019} 7020 7021func awsRestjson1_serializeDocumentTopicPreference(v *types.TopicPreference, value smithyjson.Value) error { 7022 object := value.Object() 7023 defer object.Close() 7024 7025 if len(v.SubscriptionStatus) > 0 { 7026 ok := object.Key("SubscriptionStatus") 7027 ok.String(string(v.SubscriptionStatus)) 7028 } 7029 7030 if v.TopicName != nil { 7031 ok := object.Key("TopicName") 7032 ok.String(*v.TopicName) 7033 } 7034 7035 return nil 7036} 7037 7038func awsRestjson1_serializeDocumentTopicPreferenceList(v []types.TopicPreference, value smithyjson.Value) error { 7039 array := value.Array() 7040 defer array.Close() 7041 7042 for i := range v { 7043 av := array.Value() 7044 if err := awsRestjson1_serializeDocumentTopicPreference(&v[i], av); err != nil { 7045 return err 7046 } 7047 } 7048 return nil 7049} 7050 7051func awsRestjson1_serializeDocumentTopics(v []types.Topic, value smithyjson.Value) error { 7052 array := value.Array() 7053 defer array.Close() 7054 7055 for i := range v { 7056 av := array.Value() 7057 if err := awsRestjson1_serializeDocumentTopic(&v[i], av); err != nil { 7058 return err 7059 } 7060 } 7061 return nil 7062} 7063 7064func awsRestjson1_serializeDocumentTrackingOptions(v *types.TrackingOptions, value smithyjson.Value) error { 7065 object := value.Object() 7066 defer object.Close() 7067 7068 if v.CustomRedirectDomain != nil { 7069 ok := object.Key("CustomRedirectDomain") 7070 ok.String(*v.CustomRedirectDomain) 7071 } 7072 7073 return nil 7074} 7075