1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package ses 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/aws/protocol/query" 10 "github.com/aws/aws-sdk-go-v2/service/ses/types" 11 smithy "github.com/aws/smithy-go" 12 "github.com/aws/smithy-go/encoding/httpbinding" 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 awsAwsquery_serializeOpCloneReceiptRuleSet struct { 19} 20 21func (*awsAwsquery_serializeOpCloneReceiptRuleSet) ID() string { 22 return "OperationSerializer" 23} 24 25func (m *awsAwsquery_serializeOpCloneReceiptRuleSet) 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.(*CloneReceiptRuleSetInput) 34 _ = input 35 if !ok { 36 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 37 } 38 39 request.Request.URL.Path = "/" 40 request.Request.Method = "POST" 41 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 42 if err != nil { 43 return out, metadata, &smithy.SerializationError{Err: err} 44 } 45 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 46 47 bodyWriter := bytes.NewBuffer(nil) 48 bodyEncoder := query.NewEncoder(bodyWriter) 49 body := bodyEncoder.Object() 50 body.Key("Action").String("CloneReceiptRuleSet") 51 body.Key("Version").String("2010-12-01") 52 53 if err := awsAwsquery_serializeOpDocumentCloneReceiptRuleSetInput(input, bodyEncoder.Value); err != nil { 54 return out, metadata, &smithy.SerializationError{Err: err} 55 } 56 57 err = bodyEncoder.Encode() 58 if err != nil { 59 return out, metadata, &smithy.SerializationError{Err: err} 60 } 61 62 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 63 return out, metadata, &smithy.SerializationError{Err: err} 64 } 65 66 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 67 return out, metadata, &smithy.SerializationError{Err: err} 68 } 69 in.Request = request 70 71 return next.HandleSerialize(ctx, in) 72} 73 74type awsAwsquery_serializeOpCreateConfigurationSet struct { 75} 76 77func (*awsAwsquery_serializeOpCreateConfigurationSet) ID() string { 78 return "OperationSerializer" 79} 80 81func (m *awsAwsquery_serializeOpCreateConfigurationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 82 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 83) { 84 request, ok := in.Request.(*smithyhttp.Request) 85 if !ok { 86 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 87 } 88 89 input, ok := in.Parameters.(*CreateConfigurationSetInput) 90 _ = input 91 if !ok { 92 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 93 } 94 95 request.Request.URL.Path = "/" 96 request.Request.Method = "POST" 97 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 98 if err != nil { 99 return out, metadata, &smithy.SerializationError{Err: err} 100 } 101 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 102 103 bodyWriter := bytes.NewBuffer(nil) 104 bodyEncoder := query.NewEncoder(bodyWriter) 105 body := bodyEncoder.Object() 106 body.Key("Action").String("CreateConfigurationSet") 107 body.Key("Version").String("2010-12-01") 108 109 if err := awsAwsquery_serializeOpDocumentCreateConfigurationSetInput(input, bodyEncoder.Value); err != nil { 110 return out, metadata, &smithy.SerializationError{Err: err} 111 } 112 113 err = bodyEncoder.Encode() 114 if err != nil { 115 return out, metadata, &smithy.SerializationError{Err: err} 116 } 117 118 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 119 return out, metadata, &smithy.SerializationError{Err: err} 120 } 121 122 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 123 return out, metadata, &smithy.SerializationError{Err: err} 124 } 125 in.Request = request 126 127 return next.HandleSerialize(ctx, in) 128} 129 130type awsAwsquery_serializeOpCreateConfigurationSetEventDestination struct { 131} 132 133func (*awsAwsquery_serializeOpCreateConfigurationSetEventDestination) ID() string { 134 return "OperationSerializer" 135} 136 137func (m *awsAwsquery_serializeOpCreateConfigurationSetEventDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 138 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 139) { 140 request, ok := in.Request.(*smithyhttp.Request) 141 if !ok { 142 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 143 } 144 145 input, ok := in.Parameters.(*CreateConfigurationSetEventDestinationInput) 146 _ = input 147 if !ok { 148 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 149 } 150 151 request.Request.URL.Path = "/" 152 request.Request.Method = "POST" 153 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 154 if err != nil { 155 return out, metadata, &smithy.SerializationError{Err: err} 156 } 157 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 158 159 bodyWriter := bytes.NewBuffer(nil) 160 bodyEncoder := query.NewEncoder(bodyWriter) 161 body := bodyEncoder.Object() 162 body.Key("Action").String("CreateConfigurationSetEventDestination") 163 body.Key("Version").String("2010-12-01") 164 165 if err := awsAwsquery_serializeOpDocumentCreateConfigurationSetEventDestinationInput(input, bodyEncoder.Value); err != nil { 166 return out, metadata, &smithy.SerializationError{Err: err} 167 } 168 169 err = bodyEncoder.Encode() 170 if err != nil { 171 return out, metadata, &smithy.SerializationError{Err: err} 172 } 173 174 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 175 return out, metadata, &smithy.SerializationError{Err: err} 176 } 177 178 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 179 return out, metadata, &smithy.SerializationError{Err: err} 180 } 181 in.Request = request 182 183 return next.HandleSerialize(ctx, in) 184} 185 186type awsAwsquery_serializeOpCreateConfigurationSetTrackingOptions struct { 187} 188 189func (*awsAwsquery_serializeOpCreateConfigurationSetTrackingOptions) ID() string { 190 return "OperationSerializer" 191} 192 193func (m *awsAwsquery_serializeOpCreateConfigurationSetTrackingOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 194 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 195) { 196 request, ok := in.Request.(*smithyhttp.Request) 197 if !ok { 198 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 199 } 200 201 input, ok := in.Parameters.(*CreateConfigurationSetTrackingOptionsInput) 202 _ = input 203 if !ok { 204 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 205 } 206 207 request.Request.URL.Path = "/" 208 request.Request.Method = "POST" 209 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 210 if err != nil { 211 return out, metadata, &smithy.SerializationError{Err: err} 212 } 213 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 214 215 bodyWriter := bytes.NewBuffer(nil) 216 bodyEncoder := query.NewEncoder(bodyWriter) 217 body := bodyEncoder.Object() 218 body.Key("Action").String("CreateConfigurationSetTrackingOptions") 219 body.Key("Version").String("2010-12-01") 220 221 if err := awsAwsquery_serializeOpDocumentCreateConfigurationSetTrackingOptionsInput(input, bodyEncoder.Value); err != nil { 222 return out, metadata, &smithy.SerializationError{Err: err} 223 } 224 225 err = bodyEncoder.Encode() 226 if err != nil { 227 return out, metadata, &smithy.SerializationError{Err: err} 228 } 229 230 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 231 return out, metadata, &smithy.SerializationError{Err: err} 232 } 233 234 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 235 return out, metadata, &smithy.SerializationError{Err: err} 236 } 237 in.Request = request 238 239 return next.HandleSerialize(ctx, in) 240} 241 242type awsAwsquery_serializeOpCreateCustomVerificationEmailTemplate struct { 243} 244 245func (*awsAwsquery_serializeOpCreateCustomVerificationEmailTemplate) ID() string { 246 return "OperationSerializer" 247} 248 249func (m *awsAwsquery_serializeOpCreateCustomVerificationEmailTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 250 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 251) { 252 request, ok := in.Request.(*smithyhttp.Request) 253 if !ok { 254 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 255 } 256 257 input, ok := in.Parameters.(*CreateCustomVerificationEmailTemplateInput) 258 _ = input 259 if !ok { 260 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 261 } 262 263 request.Request.URL.Path = "/" 264 request.Request.Method = "POST" 265 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 266 if err != nil { 267 return out, metadata, &smithy.SerializationError{Err: err} 268 } 269 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 270 271 bodyWriter := bytes.NewBuffer(nil) 272 bodyEncoder := query.NewEncoder(bodyWriter) 273 body := bodyEncoder.Object() 274 body.Key("Action").String("CreateCustomVerificationEmailTemplate") 275 body.Key("Version").String("2010-12-01") 276 277 if err := awsAwsquery_serializeOpDocumentCreateCustomVerificationEmailTemplateInput(input, bodyEncoder.Value); err != nil { 278 return out, metadata, &smithy.SerializationError{Err: err} 279 } 280 281 err = bodyEncoder.Encode() 282 if err != nil { 283 return out, metadata, &smithy.SerializationError{Err: err} 284 } 285 286 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 287 return out, metadata, &smithy.SerializationError{Err: err} 288 } 289 290 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 291 return out, metadata, &smithy.SerializationError{Err: err} 292 } 293 in.Request = request 294 295 return next.HandleSerialize(ctx, in) 296} 297 298type awsAwsquery_serializeOpCreateReceiptFilter struct { 299} 300 301func (*awsAwsquery_serializeOpCreateReceiptFilter) ID() string { 302 return "OperationSerializer" 303} 304 305func (m *awsAwsquery_serializeOpCreateReceiptFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 306 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 307) { 308 request, ok := in.Request.(*smithyhttp.Request) 309 if !ok { 310 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 311 } 312 313 input, ok := in.Parameters.(*CreateReceiptFilterInput) 314 _ = input 315 if !ok { 316 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 317 } 318 319 request.Request.URL.Path = "/" 320 request.Request.Method = "POST" 321 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 322 if err != nil { 323 return out, metadata, &smithy.SerializationError{Err: err} 324 } 325 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 326 327 bodyWriter := bytes.NewBuffer(nil) 328 bodyEncoder := query.NewEncoder(bodyWriter) 329 body := bodyEncoder.Object() 330 body.Key("Action").String("CreateReceiptFilter") 331 body.Key("Version").String("2010-12-01") 332 333 if err := awsAwsquery_serializeOpDocumentCreateReceiptFilterInput(input, bodyEncoder.Value); err != nil { 334 return out, metadata, &smithy.SerializationError{Err: err} 335 } 336 337 err = bodyEncoder.Encode() 338 if err != nil { 339 return out, metadata, &smithy.SerializationError{Err: err} 340 } 341 342 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 343 return out, metadata, &smithy.SerializationError{Err: err} 344 } 345 346 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 347 return out, metadata, &smithy.SerializationError{Err: err} 348 } 349 in.Request = request 350 351 return next.HandleSerialize(ctx, in) 352} 353 354type awsAwsquery_serializeOpCreateReceiptRule struct { 355} 356 357func (*awsAwsquery_serializeOpCreateReceiptRule) ID() string { 358 return "OperationSerializer" 359} 360 361func (m *awsAwsquery_serializeOpCreateReceiptRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 362 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 363) { 364 request, ok := in.Request.(*smithyhttp.Request) 365 if !ok { 366 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 367 } 368 369 input, ok := in.Parameters.(*CreateReceiptRuleInput) 370 _ = input 371 if !ok { 372 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 373 } 374 375 request.Request.URL.Path = "/" 376 request.Request.Method = "POST" 377 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 378 if err != nil { 379 return out, metadata, &smithy.SerializationError{Err: err} 380 } 381 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 382 383 bodyWriter := bytes.NewBuffer(nil) 384 bodyEncoder := query.NewEncoder(bodyWriter) 385 body := bodyEncoder.Object() 386 body.Key("Action").String("CreateReceiptRule") 387 body.Key("Version").String("2010-12-01") 388 389 if err := awsAwsquery_serializeOpDocumentCreateReceiptRuleInput(input, bodyEncoder.Value); err != nil { 390 return out, metadata, &smithy.SerializationError{Err: err} 391 } 392 393 err = bodyEncoder.Encode() 394 if err != nil { 395 return out, metadata, &smithy.SerializationError{Err: err} 396 } 397 398 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 399 return out, metadata, &smithy.SerializationError{Err: err} 400 } 401 402 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 403 return out, metadata, &smithy.SerializationError{Err: err} 404 } 405 in.Request = request 406 407 return next.HandleSerialize(ctx, in) 408} 409 410type awsAwsquery_serializeOpCreateReceiptRuleSet struct { 411} 412 413func (*awsAwsquery_serializeOpCreateReceiptRuleSet) ID() string { 414 return "OperationSerializer" 415} 416 417func (m *awsAwsquery_serializeOpCreateReceiptRuleSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 418 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 419) { 420 request, ok := in.Request.(*smithyhttp.Request) 421 if !ok { 422 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 423 } 424 425 input, ok := in.Parameters.(*CreateReceiptRuleSetInput) 426 _ = input 427 if !ok { 428 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 429 } 430 431 request.Request.URL.Path = "/" 432 request.Request.Method = "POST" 433 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 434 if err != nil { 435 return out, metadata, &smithy.SerializationError{Err: err} 436 } 437 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 438 439 bodyWriter := bytes.NewBuffer(nil) 440 bodyEncoder := query.NewEncoder(bodyWriter) 441 body := bodyEncoder.Object() 442 body.Key("Action").String("CreateReceiptRuleSet") 443 body.Key("Version").String("2010-12-01") 444 445 if err := awsAwsquery_serializeOpDocumentCreateReceiptRuleSetInput(input, bodyEncoder.Value); err != nil { 446 return out, metadata, &smithy.SerializationError{Err: err} 447 } 448 449 err = bodyEncoder.Encode() 450 if err != nil { 451 return out, metadata, &smithy.SerializationError{Err: err} 452 } 453 454 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 455 return out, metadata, &smithy.SerializationError{Err: err} 456 } 457 458 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 459 return out, metadata, &smithy.SerializationError{Err: err} 460 } 461 in.Request = request 462 463 return next.HandleSerialize(ctx, in) 464} 465 466type awsAwsquery_serializeOpCreateTemplate struct { 467} 468 469func (*awsAwsquery_serializeOpCreateTemplate) ID() string { 470 return "OperationSerializer" 471} 472 473func (m *awsAwsquery_serializeOpCreateTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 474 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 475) { 476 request, ok := in.Request.(*smithyhttp.Request) 477 if !ok { 478 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 479 } 480 481 input, ok := in.Parameters.(*CreateTemplateInput) 482 _ = input 483 if !ok { 484 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 485 } 486 487 request.Request.URL.Path = "/" 488 request.Request.Method = "POST" 489 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 490 if err != nil { 491 return out, metadata, &smithy.SerializationError{Err: err} 492 } 493 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 494 495 bodyWriter := bytes.NewBuffer(nil) 496 bodyEncoder := query.NewEncoder(bodyWriter) 497 body := bodyEncoder.Object() 498 body.Key("Action").String("CreateTemplate") 499 body.Key("Version").String("2010-12-01") 500 501 if err := awsAwsquery_serializeOpDocumentCreateTemplateInput(input, bodyEncoder.Value); err != nil { 502 return out, metadata, &smithy.SerializationError{Err: err} 503 } 504 505 err = bodyEncoder.Encode() 506 if err != nil { 507 return out, metadata, &smithy.SerializationError{Err: err} 508 } 509 510 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 511 return out, metadata, &smithy.SerializationError{Err: err} 512 } 513 514 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 515 return out, metadata, &smithy.SerializationError{Err: err} 516 } 517 in.Request = request 518 519 return next.HandleSerialize(ctx, in) 520} 521 522type awsAwsquery_serializeOpDeleteConfigurationSet struct { 523} 524 525func (*awsAwsquery_serializeOpDeleteConfigurationSet) ID() string { 526 return "OperationSerializer" 527} 528 529func (m *awsAwsquery_serializeOpDeleteConfigurationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 530 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 531) { 532 request, ok := in.Request.(*smithyhttp.Request) 533 if !ok { 534 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 535 } 536 537 input, ok := in.Parameters.(*DeleteConfigurationSetInput) 538 _ = input 539 if !ok { 540 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 541 } 542 543 request.Request.URL.Path = "/" 544 request.Request.Method = "POST" 545 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 546 if err != nil { 547 return out, metadata, &smithy.SerializationError{Err: err} 548 } 549 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 550 551 bodyWriter := bytes.NewBuffer(nil) 552 bodyEncoder := query.NewEncoder(bodyWriter) 553 body := bodyEncoder.Object() 554 body.Key("Action").String("DeleteConfigurationSet") 555 body.Key("Version").String("2010-12-01") 556 557 if err := awsAwsquery_serializeOpDocumentDeleteConfigurationSetInput(input, bodyEncoder.Value); err != nil { 558 return out, metadata, &smithy.SerializationError{Err: err} 559 } 560 561 err = bodyEncoder.Encode() 562 if err != nil { 563 return out, metadata, &smithy.SerializationError{Err: err} 564 } 565 566 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 567 return out, metadata, &smithy.SerializationError{Err: err} 568 } 569 570 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 571 return out, metadata, &smithy.SerializationError{Err: err} 572 } 573 in.Request = request 574 575 return next.HandleSerialize(ctx, in) 576} 577 578type awsAwsquery_serializeOpDeleteConfigurationSetEventDestination struct { 579} 580 581func (*awsAwsquery_serializeOpDeleteConfigurationSetEventDestination) ID() string { 582 return "OperationSerializer" 583} 584 585func (m *awsAwsquery_serializeOpDeleteConfigurationSetEventDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 586 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 587) { 588 request, ok := in.Request.(*smithyhttp.Request) 589 if !ok { 590 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 591 } 592 593 input, ok := in.Parameters.(*DeleteConfigurationSetEventDestinationInput) 594 _ = input 595 if !ok { 596 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 597 } 598 599 request.Request.URL.Path = "/" 600 request.Request.Method = "POST" 601 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 602 if err != nil { 603 return out, metadata, &smithy.SerializationError{Err: err} 604 } 605 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 606 607 bodyWriter := bytes.NewBuffer(nil) 608 bodyEncoder := query.NewEncoder(bodyWriter) 609 body := bodyEncoder.Object() 610 body.Key("Action").String("DeleteConfigurationSetEventDestination") 611 body.Key("Version").String("2010-12-01") 612 613 if err := awsAwsquery_serializeOpDocumentDeleteConfigurationSetEventDestinationInput(input, bodyEncoder.Value); err != nil { 614 return out, metadata, &smithy.SerializationError{Err: err} 615 } 616 617 err = bodyEncoder.Encode() 618 if err != nil { 619 return out, metadata, &smithy.SerializationError{Err: err} 620 } 621 622 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 623 return out, metadata, &smithy.SerializationError{Err: err} 624 } 625 626 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 627 return out, metadata, &smithy.SerializationError{Err: err} 628 } 629 in.Request = request 630 631 return next.HandleSerialize(ctx, in) 632} 633 634type awsAwsquery_serializeOpDeleteConfigurationSetTrackingOptions struct { 635} 636 637func (*awsAwsquery_serializeOpDeleteConfigurationSetTrackingOptions) ID() string { 638 return "OperationSerializer" 639} 640 641func (m *awsAwsquery_serializeOpDeleteConfigurationSetTrackingOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 642 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 643) { 644 request, ok := in.Request.(*smithyhttp.Request) 645 if !ok { 646 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 647 } 648 649 input, ok := in.Parameters.(*DeleteConfigurationSetTrackingOptionsInput) 650 _ = input 651 if !ok { 652 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 653 } 654 655 request.Request.URL.Path = "/" 656 request.Request.Method = "POST" 657 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 658 if err != nil { 659 return out, metadata, &smithy.SerializationError{Err: err} 660 } 661 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 662 663 bodyWriter := bytes.NewBuffer(nil) 664 bodyEncoder := query.NewEncoder(bodyWriter) 665 body := bodyEncoder.Object() 666 body.Key("Action").String("DeleteConfigurationSetTrackingOptions") 667 body.Key("Version").String("2010-12-01") 668 669 if err := awsAwsquery_serializeOpDocumentDeleteConfigurationSetTrackingOptionsInput(input, bodyEncoder.Value); err != nil { 670 return out, metadata, &smithy.SerializationError{Err: err} 671 } 672 673 err = bodyEncoder.Encode() 674 if err != nil { 675 return out, metadata, &smithy.SerializationError{Err: err} 676 } 677 678 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 679 return out, metadata, &smithy.SerializationError{Err: err} 680 } 681 682 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 683 return out, metadata, &smithy.SerializationError{Err: err} 684 } 685 in.Request = request 686 687 return next.HandleSerialize(ctx, in) 688} 689 690type awsAwsquery_serializeOpDeleteCustomVerificationEmailTemplate struct { 691} 692 693func (*awsAwsquery_serializeOpDeleteCustomVerificationEmailTemplate) ID() string { 694 return "OperationSerializer" 695} 696 697func (m *awsAwsquery_serializeOpDeleteCustomVerificationEmailTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 698 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 699) { 700 request, ok := in.Request.(*smithyhttp.Request) 701 if !ok { 702 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 703 } 704 705 input, ok := in.Parameters.(*DeleteCustomVerificationEmailTemplateInput) 706 _ = input 707 if !ok { 708 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 709 } 710 711 request.Request.URL.Path = "/" 712 request.Request.Method = "POST" 713 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 714 if err != nil { 715 return out, metadata, &smithy.SerializationError{Err: err} 716 } 717 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 718 719 bodyWriter := bytes.NewBuffer(nil) 720 bodyEncoder := query.NewEncoder(bodyWriter) 721 body := bodyEncoder.Object() 722 body.Key("Action").String("DeleteCustomVerificationEmailTemplate") 723 body.Key("Version").String("2010-12-01") 724 725 if err := awsAwsquery_serializeOpDocumentDeleteCustomVerificationEmailTemplateInput(input, bodyEncoder.Value); err != nil { 726 return out, metadata, &smithy.SerializationError{Err: err} 727 } 728 729 err = bodyEncoder.Encode() 730 if err != nil { 731 return out, metadata, &smithy.SerializationError{Err: err} 732 } 733 734 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 735 return out, metadata, &smithy.SerializationError{Err: err} 736 } 737 738 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 739 return out, metadata, &smithy.SerializationError{Err: err} 740 } 741 in.Request = request 742 743 return next.HandleSerialize(ctx, in) 744} 745 746type awsAwsquery_serializeOpDeleteIdentity struct { 747} 748 749func (*awsAwsquery_serializeOpDeleteIdentity) ID() string { 750 return "OperationSerializer" 751} 752 753func (m *awsAwsquery_serializeOpDeleteIdentity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 754 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 755) { 756 request, ok := in.Request.(*smithyhttp.Request) 757 if !ok { 758 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 759 } 760 761 input, ok := in.Parameters.(*DeleteIdentityInput) 762 _ = input 763 if !ok { 764 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 765 } 766 767 request.Request.URL.Path = "/" 768 request.Request.Method = "POST" 769 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 770 if err != nil { 771 return out, metadata, &smithy.SerializationError{Err: err} 772 } 773 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 774 775 bodyWriter := bytes.NewBuffer(nil) 776 bodyEncoder := query.NewEncoder(bodyWriter) 777 body := bodyEncoder.Object() 778 body.Key("Action").String("DeleteIdentity") 779 body.Key("Version").String("2010-12-01") 780 781 if err := awsAwsquery_serializeOpDocumentDeleteIdentityInput(input, bodyEncoder.Value); err != nil { 782 return out, metadata, &smithy.SerializationError{Err: err} 783 } 784 785 err = bodyEncoder.Encode() 786 if err != nil { 787 return out, metadata, &smithy.SerializationError{Err: err} 788 } 789 790 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 791 return out, metadata, &smithy.SerializationError{Err: err} 792 } 793 794 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 795 return out, metadata, &smithy.SerializationError{Err: err} 796 } 797 in.Request = request 798 799 return next.HandleSerialize(ctx, in) 800} 801 802type awsAwsquery_serializeOpDeleteIdentityPolicy struct { 803} 804 805func (*awsAwsquery_serializeOpDeleteIdentityPolicy) ID() string { 806 return "OperationSerializer" 807} 808 809func (m *awsAwsquery_serializeOpDeleteIdentityPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 810 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 811) { 812 request, ok := in.Request.(*smithyhttp.Request) 813 if !ok { 814 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 815 } 816 817 input, ok := in.Parameters.(*DeleteIdentityPolicyInput) 818 _ = input 819 if !ok { 820 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 821 } 822 823 request.Request.URL.Path = "/" 824 request.Request.Method = "POST" 825 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 826 if err != nil { 827 return out, metadata, &smithy.SerializationError{Err: err} 828 } 829 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 830 831 bodyWriter := bytes.NewBuffer(nil) 832 bodyEncoder := query.NewEncoder(bodyWriter) 833 body := bodyEncoder.Object() 834 body.Key("Action").String("DeleteIdentityPolicy") 835 body.Key("Version").String("2010-12-01") 836 837 if err := awsAwsquery_serializeOpDocumentDeleteIdentityPolicyInput(input, bodyEncoder.Value); err != nil { 838 return out, metadata, &smithy.SerializationError{Err: err} 839 } 840 841 err = bodyEncoder.Encode() 842 if err != nil { 843 return out, metadata, &smithy.SerializationError{Err: err} 844 } 845 846 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 847 return out, metadata, &smithy.SerializationError{Err: err} 848 } 849 850 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 851 return out, metadata, &smithy.SerializationError{Err: err} 852 } 853 in.Request = request 854 855 return next.HandleSerialize(ctx, in) 856} 857 858type awsAwsquery_serializeOpDeleteReceiptFilter struct { 859} 860 861func (*awsAwsquery_serializeOpDeleteReceiptFilter) ID() string { 862 return "OperationSerializer" 863} 864 865func (m *awsAwsquery_serializeOpDeleteReceiptFilter) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 866 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 867) { 868 request, ok := in.Request.(*smithyhttp.Request) 869 if !ok { 870 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 871 } 872 873 input, ok := in.Parameters.(*DeleteReceiptFilterInput) 874 _ = input 875 if !ok { 876 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 877 } 878 879 request.Request.URL.Path = "/" 880 request.Request.Method = "POST" 881 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 882 if err != nil { 883 return out, metadata, &smithy.SerializationError{Err: err} 884 } 885 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 886 887 bodyWriter := bytes.NewBuffer(nil) 888 bodyEncoder := query.NewEncoder(bodyWriter) 889 body := bodyEncoder.Object() 890 body.Key("Action").String("DeleteReceiptFilter") 891 body.Key("Version").String("2010-12-01") 892 893 if err := awsAwsquery_serializeOpDocumentDeleteReceiptFilterInput(input, bodyEncoder.Value); err != nil { 894 return out, metadata, &smithy.SerializationError{Err: err} 895 } 896 897 err = bodyEncoder.Encode() 898 if err != nil { 899 return out, metadata, &smithy.SerializationError{Err: err} 900 } 901 902 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 903 return out, metadata, &smithy.SerializationError{Err: err} 904 } 905 906 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 907 return out, metadata, &smithy.SerializationError{Err: err} 908 } 909 in.Request = request 910 911 return next.HandleSerialize(ctx, in) 912} 913 914type awsAwsquery_serializeOpDeleteReceiptRule struct { 915} 916 917func (*awsAwsquery_serializeOpDeleteReceiptRule) ID() string { 918 return "OperationSerializer" 919} 920 921func (m *awsAwsquery_serializeOpDeleteReceiptRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 922 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 923) { 924 request, ok := in.Request.(*smithyhttp.Request) 925 if !ok { 926 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 927 } 928 929 input, ok := in.Parameters.(*DeleteReceiptRuleInput) 930 _ = input 931 if !ok { 932 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 933 } 934 935 request.Request.URL.Path = "/" 936 request.Request.Method = "POST" 937 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 938 if err != nil { 939 return out, metadata, &smithy.SerializationError{Err: err} 940 } 941 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 942 943 bodyWriter := bytes.NewBuffer(nil) 944 bodyEncoder := query.NewEncoder(bodyWriter) 945 body := bodyEncoder.Object() 946 body.Key("Action").String("DeleteReceiptRule") 947 body.Key("Version").String("2010-12-01") 948 949 if err := awsAwsquery_serializeOpDocumentDeleteReceiptRuleInput(input, bodyEncoder.Value); err != nil { 950 return out, metadata, &smithy.SerializationError{Err: err} 951 } 952 953 err = bodyEncoder.Encode() 954 if err != nil { 955 return out, metadata, &smithy.SerializationError{Err: err} 956 } 957 958 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 959 return out, metadata, &smithy.SerializationError{Err: err} 960 } 961 962 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 963 return out, metadata, &smithy.SerializationError{Err: err} 964 } 965 in.Request = request 966 967 return next.HandleSerialize(ctx, in) 968} 969 970type awsAwsquery_serializeOpDeleteReceiptRuleSet struct { 971} 972 973func (*awsAwsquery_serializeOpDeleteReceiptRuleSet) ID() string { 974 return "OperationSerializer" 975} 976 977func (m *awsAwsquery_serializeOpDeleteReceiptRuleSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 978 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 979) { 980 request, ok := in.Request.(*smithyhttp.Request) 981 if !ok { 982 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 983 } 984 985 input, ok := in.Parameters.(*DeleteReceiptRuleSetInput) 986 _ = input 987 if !ok { 988 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 989 } 990 991 request.Request.URL.Path = "/" 992 request.Request.Method = "POST" 993 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 994 if err != nil { 995 return out, metadata, &smithy.SerializationError{Err: err} 996 } 997 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 998 999 bodyWriter := bytes.NewBuffer(nil) 1000 bodyEncoder := query.NewEncoder(bodyWriter) 1001 body := bodyEncoder.Object() 1002 body.Key("Action").String("DeleteReceiptRuleSet") 1003 body.Key("Version").String("2010-12-01") 1004 1005 if err := awsAwsquery_serializeOpDocumentDeleteReceiptRuleSetInput(input, bodyEncoder.Value); err != nil { 1006 return out, metadata, &smithy.SerializationError{Err: err} 1007 } 1008 1009 err = bodyEncoder.Encode() 1010 if err != nil { 1011 return out, metadata, &smithy.SerializationError{Err: err} 1012 } 1013 1014 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1015 return out, metadata, &smithy.SerializationError{Err: err} 1016 } 1017 1018 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1019 return out, metadata, &smithy.SerializationError{Err: err} 1020 } 1021 in.Request = request 1022 1023 return next.HandleSerialize(ctx, in) 1024} 1025 1026type awsAwsquery_serializeOpDeleteTemplate struct { 1027} 1028 1029func (*awsAwsquery_serializeOpDeleteTemplate) ID() string { 1030 return "OperationSerializer" 1031} 1032 1033func (m *awsAwsquery_serializeOpDeleteTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1034 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1035) { 1036 request, ok := in.Request.(*smithyhttp.Request) 1037 if !ok { 1038 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1039 } 1040 1041 input, ok := in.Parameters.(*DeleteTemplateInput) 1042 _ = input 1043 if !ok { 1044 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1045 } 1046 1047 request.Request.URL.Path = "/" 1048 request.Request.Method = "POST" 1049 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1050 if err != nil { 1051 return out, metadata, &smithy.SerializationError{Err: err} 1052 } 1053 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1054 1055 bodyWriter := bytes.NewBuffer(nil) 1056 bodyEncoder := query.NewEncoder(bodyWriter) 1057 body := bodyEncoder.Object() 1058 body.Key("Action").String("DeleteTemplate") 1059 body.Key("Version").String("2010-12-01") 1060 1061 if err := awsAwsquery_serializeOpDocumentDeleteTemplateInput(input, bodyEncoder.Value); err != nil { 1062 return out, metadata, &smithy.SerializationError{Err: err} 1063 } 1064 1065 err = bodyEncoder.Encode() 1066 if err != nil { 1067 return out, metadata, &smithy.SerializationError{Err: err} 1068 } 1069 1070 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1071 return out, metadata, &smithy.SerializationError{Err: err} 1072 } 1073 1074 if request.Request, err = httpBindingEncoder.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} 1081 1082type awsAwsquery_serializeOpDeleteVerifiedEmailAddress struct { 1083} 1084 1085func (*awsAwsquery_serializeOpDeleteVerifiedEmailAddress) ID() string { 1086 return "OperationSerializer" 1087} 1088 1089func (m *awsAwsquery_serializeOpDeleteVerifiedEmailAddress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1090 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1091) { 1092 request, ok := in.Request.(*smithyhttp.Request) 1093 if !ok { 1094 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1095 } 1096 1097 input, ok := in.Parameters.(*DeleteVerifiedEmailAddressInput) 1098 _ = input 1099 if !ok { 1100 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1101 } 1102 1103 request.Request.URL.Path = "/" 1104 request.Request.Method = "POST" 1105 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1106 if err != nil { 1107 return out, metadata, &smithy.SerializationError{Err: err} 1108 } 1109 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1110 1111 bodyWriter := bytes.NewBuffer(nil) 1112 bodyEncoder := query.NewEncoder(bodyWriter) 1113 body := bodyEncoder.Object() 1114 body.Key("Action").String("DeleteVerifiedEmailAddress") 1115 body.Key("Version").String("2010-12-01") 1116 1117 if err := awsAwsquery_serializeOpDocumentDeleteVerifiedEmailAddressInput(input, bodyEncoder.Value); err != nil { 1118 return out, metadata, &smithy.SerializationError{Err: err} 1119 } 1120 1121 err = bodyEncoder.Encode() 1122 if err != nil { 1123 return out, metadata, &smithy.SerializationError{Err: err} 1124 } 1125 1126 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1127 return out, metadata, &smithy.SerializationError{Err: err} 1128 } 1129 1130 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1131 return out, metadata, &smithy.SerializationError{Err: err} 1132 } 1133 in.Request = request 1134 1135 return next.HandleSerialize(ctx, in) 1136} 1137 1138type awsAwsquery_serializeOpDescribeActiveReceiptRuleSet struct { 1139} 1140 1141func (*awsAwsquery_serializeOpDescribeActiveReceiptRuleSet) ID() string { 1142 return "OperationSerializer" 1143} 1144 1145func (m *awsAwsquery_serializeOpDescribeActiveReceiptRuleSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1146 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1147) { 1148 request, ok := in.Request.(*smithyhttp.Request) 1149 if !ok { 1150 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1151 } 1152 1153 input, ok := in.Parameters.(*DescribeActiveReceiptRuleSetInput) 1154 _ = input 1155 if !ok { 1156 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1157 } 1158 1159 request.Request.URL.Path = "/" 1160 request.Request.Method = "POST" 1161 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1162 if err != nil { 1163 return out, metadata, &smithy.SerializationError{Err: err} 1164 } 1165 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1166 1167 bodyWriter := bytes.NewBuffer(nil) 1168 bodyEncoder := query.NewEncoder(bodyWriter) 1169 body := bodyEncoder.Object() 1170 body.Key("Action").String("DescribeActiveReceiptRuleSet") 1171 body.Key("Version").String("2010-12-01") 1172 1173 err = bodyEncoder.Encode() 1174 if err != nil { 1175 return out, metadata, &smithy.SerializationError{Err: err} 1176 } 1177 1178 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1179 return out, metadata, &smithy.SerializationError{Err: err} 1180 } 1181 1182 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1183 return out, metadata, &smithy.SerializationError{Err: err} 1184 } 1185 in.Request = request 1186 1187 return next.HandleSerialize(ctx, in) 1188} 1189 1190type awsAwsquery_serializeOpDescribeConfigurationSet struct { 1191} 1192 1193func (*awsAwsquery_serializeOpDescribeConfigurationSet) ID() string { 1194 return "OperationSerializer" 1195} 1196 1197func (m *awsAwsquery_serializeOpDescribeConfigurationSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1198 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1199) { 1200 request, ok := in.Request.(*smithyhttp.Request) 1201 if !ok { 1202 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1203 } 1204 1205 input, ok := in.Parameters.(*DescribeConfigurationSetInput) 1206 _ = input 1207 if !ok { 1208 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1209 } 1210 1211 request.Request.URL.Path = "/" 1212 request.Request.Method = "POST" 1213 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1214 if err != nil { 1215 return out, metadata, &smithy.SerializationError{Err: err} 1216 } 1217 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1218 1219 bodyWriter := bytes.NewBuffer(nil) 1220 bodyEncoder := query.NewEncoder(bodyWriter) 1221 body := bodyEncoder.Object() 1222 body.Key("Action").String("DescribeConfigurationSet") 1223 body.Key("Version").String("2010-12-01") 1224 1225 if err := awsAwsquery_serializeOpDocumentDescribeConfigurationSetInput(input, bodyEncoder.Value); err != nil { 1226 return out, metadata, &smithy.SerializationError{Err: err} 1227 } 1228 1229 err = bodyEncoder.Encode() 1230 if err != nil { 1231 return out, metadata, &smithy.SerializationError{Err: err} 1232 } 1233 1234 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1235 return out, metadata, &smithy.SerializationError{Err: err} 1236 } 1237 1238 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1239 return out, metadata, &smithy.SerializationError{Err: err} 1240 } 1241 in.Request = request 1242 1243 return next.HandleSerialize(ctx, in) 1244} 1245 1246type awsAwsquery_serializeOpDescribeReceiptRule struct { 1247} 1248 1249func (*awsAwsquery_serializeOpDescribeReceiptRule) ID() string { 1250 return "OperationSerializer" 1251} 1252 1253func (m *awsAwsquery_serializeOpDescribeReceiptRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1254 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1255) { 1256 request, ok := in.Request.(*smithyhttp.Request) 1257 if !ok { 1258 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1259 } 1260 1261 input, ok := in.Parameters.(*DescribeReceiptRuleInput) 1262 _ = input 1263 if !ok { 1264 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1265 } 1266 1267 request.Request.URL.Path = "/" 1268 request.Request.Method = "POST" 1269 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1270 if err != nil { 1271 return out, metadata, &smithy.SerializationError{Err: err} 1272 } 1273 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1274 1275 bodyWriter := bytes.NewBuffer(nil) 1276 bodyEncoder := query.NewEncoder(bodyWriter) 1277 body := bodyEncoder.Object() 1278 body.Key("Action").String("DescribeReceiptRule") 1279 body.Key("Version").String("2010-12-01") 1280 1281 if err := awsAwsquery_serializeOpDocumentDescribeReceiptRuleInput(input, bodyEncoder.Value); err != nil { 1282 return out, metadata, &smithy.SerializationError{Err: err} 1283 } 1284 1285 err = bodyEncoder.Encode() 1286 if err != nil { 1287 return out, metadata, &smithy.SerializationError{Err: err} 1288 } 1289 1290 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1291 return out, metadata, &smithy.SerializationError{Err: err} 1292 } 1293 1294 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1295 return out, metadata, &smithy.SerializationError{Err: err} 1296 } 1297 in.Request = request 1298 1299 return next.HandleSerialize(ctx, in) 1300} 1301 1302type awsAwsquery_serializeOpDescribeReceiptRuleSet struct { 1303} 1304 1305func (*awsAwsquery_serializeOpDescribeReceiptRuleSet) ID() string { 1306 return "OperationSerializer" 1307} 1308 1309func (m *awsAwsquery_serializeOpDescribeReceiptRuleSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1310 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1311) { 1312 request, ok := in.Request.(*smithyhttp.Request) 1313 if !ok { 1314 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1315 } 1316 1317 input, ok := in.Parameters.(*DescribeReceiptRuleSetInput) 1318 _ = input 1319 if !ok { 1320 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1321 } 1322 1323 request.Request.URL.Path = "/" 1324 request.Request.Method = "POST" 1325 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1326 if err != nil { 1327 return out, metadata, &smithy.SerializationError{Err: err} 1328 } 1329 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1330 1331 bodyWriter := bytes.NewBuffer(nil) 1332 bodyEncoder := query.NewEncoder(bodyWriter) 1333 body := bodyEncoder.Object() 1334 body.Key("Action").String("DescribeReceiptRuleSet") 1335 body.Key("Version").String("2010-12-01") 1336 1337 if err := awsAwsquery_serializeOpDocumentDescribeReceiptRuleSetInput(input, bodyEncoder.Value); err != nil { 1338 return out, metadata, &smithy.SerializationError{Err: err} 1339 } 1340 1341 err = bodyEncoder.Encode() 1342 if err != nil { 1343 return out, metadata, &smithy.SerializationError{Err: err} 1344 } 1345 1346 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1347 return out, metadata, &smithy.SerializationError{Err: err} 1348 } 1349 1350 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1351 return out, metadata, &smithy.SerializationError{Err: err} 1352 } 1353 in.Request = request 1354 1355 return next.HandleSerialize(ctx, in) 1356} 1357 1358type awsAwsquery_serializeOpGetAccountSendingEnabled struct { 1359} 1360 1361func (*awsAwsquery_serializeOpGetAccountSendingEnabled) ID() string { 1362 return "OperationSerializer" 1363} 1364 1365func (m *awsAwsquery_serializeOpGetAccountSendingEnabled) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1366 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1367) { 1368 request, ok := in.Request.(*smithyhttp.Request) 1369 if !ok { 1370 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1371 } 1372 1373 input, ok := in.Parameters.(*GetAccountSendingEnabledInput) 1374 _ = input 1375 if !ok { 1376 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1377 } 1378 1379 request.Request.URL.Path = "/" 1380 request.Request.Method = "POST" 1381 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1382 if err != nil { 1383 return out, metadata, &smithy.SerializationError{Err: err} 1384 } 1385 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1386 1387 bodyWriter := bytes.NewBuffer(nil) 1388 bodyEncoder := query.NewEncoder(bodyWriter) 1389 body := bodyEncoder.Object() 1390 body.Key("Action").String("GetAccountSendingEnabled") 1391 body.Key("Version").String("2010-12-01") 1392 1393 err = bodyEncoder.Encode() 1394 if err != nil { 1395 return out, metadata, &smithy.SerializationError{Err: err} 1396 } 1397 1398 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1399 return out, metadata, &smithy.SerializationError{Err: err} 1400 } 1401 1402 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1403 return out, metadata, &smithy.SerializationError{Err: err} 1404 } 1405 in.Request = request 1406 1407 return next.HandleSerialize(ctx, in) 1408} 1409 1410type awsAwsquery_serializeOpGetCustomVerificationEmailTemplate struct { 1411} 1412 1413func (*awsAwsquery_serializeOpGetCustomVerificationEmailTemplate) ID() string { 1414 return "OperationSerializer" 1415} 1416 1417func (m *awsAwsquery_serializeOpGetCustomVerificationEmailTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1418 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1419) { 1420 request, ok := in.Request.(*smithyhttp.Request) 1421 if !ok { 1422 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1423 } 1424 1425 input, ok := in.Parameters.(*GetCustomVerificationEmailTemplateInput) 1426 _ = input 1427 if !ok { 1428 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1429 } 1430 1431 request.Request.URL.Path = "/" 1432 request.Request.Method = "POST" 1433 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1434 if err != nil { 1435 return out, metadata, &smithy.SerializationError{Err: err} 1436 } 1437 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1438 1439 bodyWriter := bytes.NewBuffer(nil) 1440 bodyEncoder := query.NewEncoder(bodyWriter) 1441 body := bodyEncoder.Object() 1442 body.Key("Action").String("GetCustomVerificationEmailTemplate") 1443 body.Key("Version").String("2010-12-01") 1444 1445 if err := awsAwsquery_serializeOpDocumentGetCustomVerificationEmailTemplateInput(input, bodyEncoder.Value); err != nil { 1446 return out, metadata, &smithy.SerializationError{Err: err} 1447 } 1448 1449 err = bodyEncoder.Encode() 1450 if err != nil { 1451 return out, metadata, &smithy.SerializationError{Err: err} 1452 } 1453 1454 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1455 return out, metadata, &smithy.SerializationError{Err: err} 1456 } 1457 1458 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1459 return out, metadata, &smithy.SerializationError{Err: err} 1460 } 1461 in.Request = request 1462 1463 return next.HandleSerialize(ctx, in) 1464} 1465 1466type awsAwsquery_serializeOpGetIdentityDkimAttributes struct { 1467} 1468 1469func (*awsAwsquery_serializeOpGetIdentityDkimAttributes) ID() string { 1470 return "OperationSerializer" 1471} 1472 1473func (m *awsAwsquery_serializeOpGetIdentityDkimAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1474 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1475) { 1476 request, ok := in.Request.(*smithyhttp.Request) 1477 if !ok { 1478 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1479 } 1480 1481 input, ok := in.Parameters.(*GetIdentityDkimAttributesInput) 1482 _ = input 1483 if !ok { 1484 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1485 } 1486 1487 request.Request.URL.Path = "/" 1488 request.Request.Method = "POST" 1489 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1490 if err != nil { 1491 return out, metadata, &smithy.SerializationError{Err: err} 1492 } 1493 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1494 1495 bodyWriter := bytes.NewBuffer(nil) 1496 bodyEncoder := query.NewEncoder(bodyWriter) 1497 body := bodyEncoder.Object() 1498 body.Key("Action").String("GetIdentityDkimAttributes") 1499 body.Key("Version").String("2010-12-01") 1500 1501 if err := awsAwsquery_serializeOpDocumentGetIdentityDkimAttributesInput(input, bodyEncoder.Value); err != nil { 1502 return out, metadata, &smithy.SerializationError{Err: err} 1503 } 1504 1505 err = bodyEncoder.Encode() 1506 if err != nil { 1507 return out, metadata, &smithy.SerializationError{Err: err} 1508 } 1509 1510 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1511 return out, metadata, &smithy.SerializationError{Err: err} 1512 } 1513 1514 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1515 return out, metadata, &smithy.SerializationError{Err: err} 1516 } 1517 in.Request = request 1518 1519 return next.HandleSerialize(ctx, in) 1520} 1521 1522type awsAwsquery_serializeOpGetIdentityMailFromDomainAttributes struct { 1523} 1524 1525func (*awsAwsquery_serializeOpGetIdentityMailFromDomainAttributes) ID() string { 1526 return "OperationSerializer" 1527} 1528 1529func (m *awsAwsquery_serializeOpGetIdentityMailFromDomainAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1530 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1531) { 1532 request, ok := in.Request.(*smithyhttp.Request) 1533 if !ok { 1534 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1535 } 1536 1537 input, ok := in.Parameters.(*GetIdentityMailFromDomainAttributesInput) 1538 _ = input 1539 if !ok { 1540 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1541 } 1542 1543 request.Request.URL.Path = "/" 1544 request.Request.Method = "POST" 1545 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1546 if err != nil { 1547 return out, metadata, &smithy.SerializationError{Err: err} 1548 } 1549 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1550 1551 bodyWriter := bytes.NewBuffer(nil) 1552 bodyEncoder := query.NewEncoder(bodyWriter) 1553 body := bodyEncoder.Object() 1554 body.Key("Action").String("GetIdentityMailFromDomainAttributes") 1555 body.Key("Version").String("2010-12-01") 1556 1557 if err := awsAwsquery_serializeOpDocumentGetIdentityMailFromDomainAttributesInput(input, bodyEncoder.Value); err != nil { 1558 return out, metadata, &smithy.SerializationError{Err: err} 1559 } 1560 1561 err = bodyEncoder.Encode() 1562 if err != nil { 1563 return out, metadata, &smithy.SerializationError{Err: err} 1564 } 1565 1566 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1567 return out, metadata, &smithy.SerializationError{Err: err} 1568 } 1569 1570 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1571 return out, metadata, &smithy.SerializationError{Err: err} 1572 } 1573 in.Request = request 1574 1575 return next.HandleSerialize(ctx, in) 1576} 1577 1578type awsAwsquery_serializeOpGetIdentityNotificationAttributes struct { 1579} 1580 1581func (*awsAwsquery_serializeOpGetIdentityNotificationAttributes) ID() string { 1582 return "OperationSerializer" 1583} 1584 1585func (m *awsAwsquery_serializeOpGetIdentityNotificationAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1586 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1587) { 1588 request, ok := in.Request.(*smithyhttp.Request) 1589 if !ok { 1590 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1591 } 1592 1593 input, ok := in.Parameters.(*GetIdentityNotificationAttributesInput) 1594 _ = input 1595 if !ok { 1596 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1597 } 1598 1599 request.Request.URL.Path = "/" 1600 request.Request.Method = "POST" 1601 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1602 if err != nil { 1603 return out, metadata, &smithy.SerializationError{Err: err} 1604 } 1605 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1606 1607 bodyWriter := bytes.NewBuffer(nil) 1608 bodyEncoder := query.NewEncoder(bodyWriter) 1609 body := bodyEncoder.Object() 1610 body.Key("Action").String("GetIdentityNotificationAttributes") 1611 body.Key("Version").String("2010-12-01") 1612 1613 if err := awsAwsquery_serializeOpDocumentGetIdentityNotificationAttributesInput(input, bodyEncoder.Value); err != nil { 1614 return out, metadata, &smithy.SerializationError{Err: err} 1615 } 1616 1617 err = bodyEncoder.Encode() 1618 if err != nil { 1619 return out, metadata, &smithy.SerializationError{Err: err} 1620 } 1621 1622 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1623 return out, metadata, &smithy.SerializationError{Err: err} 1624 } 1625 1626 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1627 return out, metadata, &smithy.SerializationError{Err: err} 1628 } 1629 in.Request = request 1630 1631 return next.HandleSerialize(ctx, in) 1632} 1633 1634type awsAwsquery_serializeOpGetIdentityPolicies struct { 1635} 1636 1637func (*awsAwsquery_serializeOpGetIdentityPolicies) ID() string { 1638 return "OperationSerializer" 1639} 1640 1641func (m *awsAwsquery_serializeOpGetIdentityPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1642 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1643) { 1644 request, ok := in.Request.(*smithyhttp.Request) 1645 if !ok { 1646 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1647 } 1648 1649 input, ok := in.Parameters.(*GetIdentityPoliciesInput) 1650 _ = input 1651 if !ok { 1652 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1653 } 1654 1655 request.Request.URL.Path = "/" 1656 request.Request.Method = "POST" 1657 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1658 if err != nil { 1659 return out, metadata, &smithy.SerializationError{Err: err} 1660 } 1661 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1662 1663 bodyWriter := bytes.NewBuffer(nil) 1664 bodyEncoder := query.NewEncoder(bodyWriter) 1665 body := bodyEncoder.Object() 1666 body.Key("Action").String("GetIdentityPolicies") 1667 body.Key("Version").String("2010-12-01") 1668 1669 if err := awsAwsquery_serializeOpDocumentGetIdentityPoliciesInput(input, bodyEncoder.Value); err != nil { 1670 return out, metadata, &smithy.SerializationError{Err: err} 1671 } 1672 1673 err = bodyEncoder.Encode() 1674 if err != nil { 1675 return out, metadata, &smithy.SerializationError{Err: err} 1676 } 1677 1678 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1679 return out, metadata, &smithy.SerializationError{Err: err} 1680 } 1681 1682 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1683 return out, metadata, &smithy.SerializationError{Err: err} 1684 } 1685 in.Request = request 1686 1687 return next.HandleSerialize(ctx, in) 1688} 1689 1690type awsAwsquery_serializeOpGetIdentityVerificationAttributes struct { 1691} 1692 1693func (*awsAwsquery_serializeOpGetIdentityVerificationAttributes) ID() string { 1694 return "OperationSerializer" 1695} 1696 1697func (m *awsAwsquery_serializeOpGetIdentityVerificationAttributes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1698 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1699) { 1700 request, ok := in.Request.(*smithyhttp.Request) 1701 if !ok { 1702 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1703 } 1704 1705 input, ok := in.Parameters.(*GetIdentityVerificationAttributesInput) 1706 _ = input 1707 if !ok { 1708 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1709 } 1710 1711 request.Request.URL.Path = "/" 1712 request.Request.Method = "POST" 1713 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1714 if err != nil { 1715 return out, metadata, &smithy.SerializationError{Err: err} 1716 } 1717 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1718 1719 bodyWriter := bytes.NewBuffer(nil) 1720 bodyEncoder := query.NewEncoder(bodyWriter) 1721 body := bodyEncoder.Object() 1722 body.Key("Action").String("GetIdentityVerificationAttributes") 1723 body.Key("Version").String("2010-12-01") 1724 1725 if err := awsAwsquery_serializeOpDocumentGetIdentityVerificationAttributesInput(input, bodyEncoder.Value); err != nil { 1726 return out, metadata, &smithy.SerializationError{Err: err} 1727 } 1728 1729 err = bodyEncoder.Encode() 1730 if err != nil { 1731 return out, metadata, &smithy.SerializationError{Err: err} 1732 } 1733 1734 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1735 return out, metadata, &smithy.SerializationError{Err: err} 1736 } 1737 1738 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1739 return out, metadata, &smithy.SerializationError{Err: err} 1740 } 1741 in.Request = request 1742 1743 return next.HandleSerialize(ctx, in) 1744} 1745 1746type awsAwsquery_serializeOpGetSendQuota struct { 1747} 1748 1749func (*awsAwsquery_serializeOpGetSendQuota) ID() string { 1750 return "OperationSerializer" 1751} 1752 1753func (m *awsAwsquery_serializeOpGetSendQuota) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1754 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1755) { 1756 request, ok := in.Request.(*smithyhttp.Request) 1757 if !ok { 1758 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1759 } 1760 1761 input, ok := in.Parameters.(*GetSendQuotaInput) 1762 _ = input 1763 if !ok { 1764 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1765 } 1766 1767 request.Request.URL.Path = "/" 1768 request.Request.Method = "POST" 1769 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1770 if err != nil { 1771 return out, metadata, &smithy.SerializationError{Err: err} 1772 } 1773 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1774 1775 bodyWriter := bytes.NewBuffer(nil) 1776 bodyEncoder := query.NewEncoder(bodyWriter) 1777 body := bodyEncoder.Object() 1778 body.Key("Action").String("GetSendQuota") 1779 body.Key("Version").String("2010-12-01") 1780 1781 err = bodyEncoder.Encode() 1782 if err != nil { 1783 return out, metadata, &smithy.SerializationError{Err: err} 1784 } 1785 1786 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1787 return out, metadata, &smithy.SerializationError{Err: err} 1788 } 1789 1790 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1791 return out, metadata, &smithy.SerializationError{Err: err} 1792 } 1793 in.Request = request 1794 1795 return next.HandleSerialize(ctx, in) 1796} 1797 1798type awsAwsquery_serializeOpGetSendStatistics struct { 1799} 1800 1801func (*awsAwsquery_serializeOpGetSendStatistics) ID() string { 1802 return "OperationSerializer" 1803} 1804 1805func (m *awsAwsquery_serializeOpGetSendStatistics) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1806 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1807) { 1808 request, ok := in.Request.(*smithyhttp.Request) 1809 if !ok { 1810 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1811 } 1812 1813 input, ok := in.Parameters.(*GetSendStatisticsInput) 1814 _ = input 1815 if !ok { 1816 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1817 } 1818 1819 request.Request.URL.Path = "/" 1820 request.Request.Method = "POST" 1821 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1822 if err != nil { 1823 return out, metadata, &smithy.SerializationError{Err: err} 1824 } 1825 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1826 1827 bodyWriter := bytes.NewBuffer(nil) 1828 bodyEncoder := query.NewEncoder(bodyWriter) 1829 body := bodyEncoder.Object() 1830 body.Key("Action").String("GetSendStatistics") 1831 body.Key("Version").String("2010-12-01") 1832 1833 err = bodyEncoder.Encode() 1834 if err != nil { 1835 return out, metadata, &smithy.SerializationError{Err: err} 1836 } 1837 1838 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1839 return out, metadata, &smithy.SerializationError{Err: err} 1840 } 1841 1842 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1843 return out, metadata, &smithy.SerializationError{Err: err} 1844 } 1845 in.Request = request 1846 1847 return next.HandleSerialize(ctx, in) 1848} 1849 1850type awsAwsquery_serializeOpGetTemplate struct { 1851} 1852 1853func (*awsAwsquery_serializeOpGetTemplate) ID() string { 1854 return "OperationSerializer" 1855} 1856 1857func (m *awsAwsquery_serializeOpGetTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1858 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1859) { 1860 request, ok := in.Request.(*smithyhttp.Request) 1861 if !ok { 1862 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1863 } 1864 1865 input, ok := in.Parameters.(*GetTemplateInput) 1866 _ = input 1867 if !ok { 1868 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1869 } 1870 1871 request.Request.URL.Path = "/" 1872 request.Request.Method = "POST" 1873 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1874 if err != nil { 1875 return out, metadata, &smithy.SerializationError{Err: err} 1876 } 1877 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1878 1879 bodyWriter := bytes.NewBuffer(nil) 1880 bodyEncoder := query.NewEncoder(bodyWriter) 1881 body := bodyEncoder.Object() 1882 body.Key("Action").String("GetTemplate") 1883 body.Key("Version").String("2010-12-01") 1884 1885 if err := awsAwsquery_serializeOpDocumentGetTemplateInput(input, bodyEncoder.Value); err != nil { 1886 return out, metadata, &smithy.SerializationError{Err: err} 1887 } 1888 1889 err = bodyEncoder.Encode() 1890 if err != nil { 1891 return out, metadata, &smithy.SerializationError{Err: err} 1892 } 1893 1894 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1895 return out, metadata, &smithy.SerializationError{Err: err} 1896 } 1897 1898 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1899 return out, metadata, &smithy.SerializationError{Err: err} 1900 } 1901 in.Request = request 1902 1903 return next.HandleSerialize(ctx, in) 1904} 1905 1906type awsAwsquery_serializeOpListConfigurationSets struct { 1907} 1908 1909func (*awsAwsquery_serializeOpListConfigurationSets) ID() string { 1910 return "OperationSerializer" 1911} 1912 1913func (m *awsAwsquery_serializeOpListConfigurationSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1914 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1915) { 1916 request, ok := in.Request.(*smithyhttp.Request) 1917 if !ok { 1918 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1919 } 1920 1921 input, ok := in.Parameters.(*ListConfigurationSetsInput) 1922 _ = input 1923 if !ok { 1924 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1925 } 1926 1927 request.Request.URL.Path = "/" 1928 request.Request.Method = "POST" 1929 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1930 if err != nil { 1931 return out, metadata, &smithy.SerializationError{Err: err} 1932 } 1933 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1934 1935 bodyWriter := bytes.NewBuffer(nil) 1936 bodyEncoder := query.NewEncoder(bodyWriter) 1937 body := bodyEncoder.Object() 1938 body.Key("Action").String("ListConfigurationSets") 1939 body.Key("Version").String("2010-12-01") 1940 1941 if err := awsAwsquery_serializeOpDocumentListConfigurationSetsInput(input, bodyEncoder.Value); err != nil { 1942 return out, metadata, &smithy.SerializationError{Err: err} 1943 } 1944 1945 err = bodyEncoder.Encode() 1946 if err != nil { 1947 return out, metadata, &smithy.SerializationError{Err: err} 1948 } 1949 1950 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 1951 return out, metadata, &smithy.SerializationError{Err: err} 1952 } 1953 1954 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 1955 return out, metadata, &smithy.SerializationError{Err: err} 1956 } 1957 in.Request = request 1958 1959 return next.HandleSerialize(ctx, in) 1960} 1961 1962type awsAwsquery_serializeOpListCustomVerificationEmailTemplates struct { 1963} 1964 1965func (*awsAwsquery_serializeOpListCustomVerificationEmailTemplates) ID() string { 1966 return "OperationSerializer" 1967} 1968 1969func (m *awsAwsquery_serializeOpListCustomVerificationEmailTemplates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1970 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1971) { 1972 request, ok := in.Request.(*smithyhttp.Request) 1973 if !ok { 1974 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1975 } 1976 1977 input, ok := in.Parameters.(*ListCustomVerificationEmailTemplatesInput) 1978 _ = input 1979 if !ok { 1980 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1981 } 1982 1983 request.Request.URL.Path = "/" 1984 request.Request.Method = "POST" 1985 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1986 if err != nil { 1987 return out, metadata, &smithy.SerializationError{Err: err} 1988 } 1989 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 1990 1991 bodyWriter := bytes.NewBuffer(nil) 1992 bodyEncoder := query.NewEncoder(bodyWriter) 1993 body := bodyEncoder.Object() 1994 body.Key("Action").String("ListCustomVerificationEmailTemplates") 1995 body.Key("Version").String("2010-12-01") 1996 1997 if err := awsAwsquery_serializeOpDocumentListCustomVerificationEmailTemplatesInput(input, bodyEncoder.Value); err != nil { 1998 return out, metadata, &smithy.SerializationError{Err: err} 1999 } 2000 2001 err = bodyEncoder.Encode() 2002 if err != nil { 2003 return out, metadata, &smithy.SerializationError{Err: err} 2004 } 2005 2006 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2007 return out, metadata, &smithy.SerializationError{Err: err} 2008 } 2009 2010 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2011 return out, metadata, &smithy.SerializationError{Err: err} 2012 } 2013 in.Request = request 2014 2015 return next.HandleSerialize(ctx, in) 2016} 2017 2018type awsAwsquery_serializeOpListIdentities struct { 2019} 2020 2021func (*awsAwsquery_serializeOpListIdentities) ID() string { 2022 return "OperationSerializer" 2023} 2024 2025func (m *awsAwsquery_serializeOpListIdentities) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2026 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2027) { 2028 request, ok := in.Request.(*smithyhttp.Request) 2029 if !ok { 2030 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2031 } 2032 2033 input, ok := in.Parameters.(*ListIdentitiesInput) 2034 _ = input 2035 if !ok { 2036 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2037 } 2038 2039 request.Request.URL.Path = "/" 2040 request.Request.Method = "POST" 2041 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2042 if err != nil { 2043 return out, metadata, &smithy.SerializationError{Err: err} 2044 } 2045 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2046 2047 bodyWriter := bytes.NewBuffer(nil) 2048 bodyEncoder := query.NewEncoder(bodyWriter) 2049 body := bodyEncoder.Object() 2050 body.Key("Action").String("ListIdentities") 2051 body.Key("Version").String("2010-12-01") 2052 2053 if err := awsAwsquery_serializeOpDocumentListIdentitiesInput(input, bodyEncoder.Value); err != nil { 2054 return out, metadata, &smithy.SerializationError{Err: err} 2055 } 2056 2057 err = bodyEncoder.Encode() 2058 if err != nil { 2059 return out, metadata, &smithy.SerializationError{Err: err} 2060 } 2061 2062 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2063 return out, metadata, &smithy.SerializationError{Err: err} 2064 } 2065 2066 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2067 return out, metadata, &smithy.SerializationError{Err: err} 2068 } 2069 in.Request = request 2070 2071 return next.HandleSerialize(ctx, in) 2072} 2073 2074type awsAwsquery_serializeOpListIdentityPolicies struct { 2075} 2076 2077func (*awsAwsquery_serializeOpListIdentityPolicies) ID() string { 2078 return "OperationSerializer" 2079} 2080 2081func (m *awsAwsquery_serializeOpListIdentityPolicies) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2082 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2083) { 2084 request, ok := in.Request.(*smithyhttp.Request) 2085 if !ok { 2086 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2087 } 2088 2089 input, ok := in.Parameters.(*ListIdentityPoliciesInput) 2090 _ = input 2091 if !ok { 2092 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2093 } 2094 2095 request.Request.URL.Path = "/" 2096 request.Request.Method = "POST" 2097 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2098 if err != nil { 2099 return out, metadata, &smithy.SerializationError{Err: err} 2100 } 2101 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2102 2103 bodyWriter := bytes.NewBuffer(nil) 2104 bodyEncoder := query.NewEncoder(bodyWriter) 2105 body := bodyEncoder.Object() 2106 body.Key("Action").String("ListIdentityPolicies") 2107 body.Key("Version").String("2010-12-01") 2108 2109 if err := awsAwsquery_serializeOpDocumentListIdentityPoliciesInput(input, bodyEncoder.Value); err != nil { 2110 return out, metadata, &smithy.SerializationError{Err: err} 2111 } 2112 2113 err = bodyEncoder.Encode() 2114 if err != nil { 2115 return out, metadata, &smithy.SerializationError{Err: err} 2116 } 2117 2118 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2119 return out, metadata, &smithy.SerializationError{Err: err} 2120 } 2121 2122 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2123 return out, metadata, &smithy.SerializationError{Err: err} 2124 } 2125 in.Request = request 2126 2127 return next.HandleSerialize(ctx, in) 2128} 2129 2130type awsAwsquery_serializeOpListReceiptFilters struct { 2131} 2132 2133func (*awsAwsquery_serializeOpListReceiptFilters) ID() string { 2134 return "OperationSerializer" 2135} 2136 2137func (m *awsAwsquery_serializeOpListReceiptFilters) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2138 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2139) { 2140 request, ok := in.Request.(*smithyhttp.Request) 2141 if !ok { 2142 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2143 } 2144 2145 input, ok := in.Parameters.(*ListReceiptFiltersInput) 2146 _ = input 2147 if !ok { 2148 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2149 } 2150 2151 request.Request.URL.Path = "/" 2152 request.Request.Method = "POST" 2153 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2154 if err != nil { 2155 return out, metadata, &smithy.SerializationError{Err: err} 2156 } 2157 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2158 2159 bodyWriter := bytes.NewBuffer(nil) 2160 bodyEncoder := query.NewEncoder(bodyWriter) 2161 body := bodyEncoder.Object() 2162 body.Key("Action").String("ListReceiptFilters") 2163 body.Key("Version").String("2010-12-01") 2164 2165 err = bodyEncoder.Encode() 2166 if err != nil { 2167 return out, metadata, &smithy.SerializationError{Err: err} 2168 } 2169 2170 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2171 return out, metadata, &smithy.SerializationError{Err: err} 2172 } 2173 2174 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2175 return out, metadata, &smithy.SerializationError{Err: err} 2176 } 2177 in.Request = request 2178 2179 return next.HandleSerialize(ctx, in) 2180} 2181 2182type awsAwsquery_serializeOpListReceiptRuleSets struct { 2183} 2184 2185func (*awsAwsquery_serializeOpListReceiptRuleSets) ID() string { 2186 return "OperationSerializer" 2187} 2188 2189func (m *awsAwsquery_serializeOpListReceiptRuleSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2190 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2191) { 2192 request, ok := in.Request.(*smithyhttp.Request) 2193 if !ok { 2194 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2195 } 2196 2197 input, ok := in.Parameters.(*ListReceiptRuleSetsInput) 2198 _ = input 2199 if !ok { 2200 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2201 } 2202 2203 request.Request.URL.Path = "/" 2204 request.Request.Method = "POST" 2205 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2206 if err != nil { 2207 return out, metadata, &smithy.SerializationError{Err: err} 2208 } 2209 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2210 2211 bodyWriter := bytes.NewBuffer(nil) 2212 bodyEncoder := query.NewEncoder(bodyWriter) 2213 body := bodyEncoder.Object() 2214 body.Key("Action").String("ListReceiptRuleSets") 2215 body.Key("Version").String("2010-12-01") 2216 2217 if err := awsAwsquery_serializeOpDocumentListReceiptRuleSetsInput(input, bodyEncoder.Value); err != nil { 2218 return out, metadata, &smithy.SerializationError{Err: err} 2219 } 2220 2221 err = bodyEncoder.Encode() 2222 if err != nil { 2223 return out, metadata, &smithy.SerializationError{Err: err} 2224 } 2225 2226 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2227 return out, metadata, &smithy.SerializationError{Err: err} 2228 } 2229 2230 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2231 return out, metadata, &smithy.SerializationError{Err: err} 2232 } 2233 in.Request = request 2234 2235 return next.HandleSerialize(ctx, in) 2236} 2237 2238type awsAwsquery_serializeOpListTemplates struct { 2239} 2240 2241func (*awsAwsquery_serializeOpListTemplates) ID() string { 2242 return "OperationSerializer" 2243} 2244 2245func (m *awsAwsquery_serializeOpListTemplates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2246 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2247) { 2248 request, ok := in.Request.(*smithyhttp.Request) 2249 if !ok { 2250 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2251 } 2252 2253 input, ok := in.Parameters.(*ListTemplatesInput) 2254 _ = input 2255 if !ok { 2256 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2257 } 2258 2259 request.Request.URL.Path = "/" 2260 request.Request.Method = "POST" 2261 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2262 if err != nil { 2263 return out, metadata, &smithy.SerializationError{Err: err} 2264 } 2265 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2266 2267 bodyWriter := bytes.NewBuffer(nil) 2268 bodyEncoder := query.NewEncoder(bodyWriter) 2269 body := bodyEncoder.Object() 2270 body.Key("Action").String("ListTemplates") 2271 body.Key("Version").String("2010-12-01") 2272 2273 if err := awsAwsquery_serializeOpDocumentListTemplatesInput(input, bodyEncoder.Value); err != nil { 2274 return out, metadata, &smithy.SerializationError{Err: err} 2275 } 2276 2277 err = bodyEncoder.Encode() 2278 if err != nil { 2279 return out, metadata, &smithy.SerializationError{Err: err} 2280 } 2281 2282 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2283 return out, metadata, &smithy.SerializationError{Err: err} 2284 } 2285 2286 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2287 return out, metadata, &smithy.SerializationError{Err: err} 2288 } 2289 in.Request = request 2290 2291 return next.HandleSerialize(ctx, in) 2292} 2293 2294type awsAwsquery_serializeOpListVerifiedEmailAddresses struct { 2295} 2296 2297func (*awsAwsquery_serializeOpListVerifiedEmailAddresses) ID() string { 2298 return "OperationSerializer" 2299} 2300 2301func (m *awsAwsquery_serializeOpListVerifiedEmailAddresses) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2302 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2303) { 2304 request, ok := in.Request.(*smithyhttp.Request) 2305 if !ok { 2306 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2307 } 2308 2309 input, ok := in.Parameters.(*ListVerifiedEmailAddressesInput) 2310 _ = input 2311 if !ok { 2312 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2313 } 2314 2315 request.Request.URL.Path = "/" 2316 request.Request.Method = "POST" 2317 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2318 if err != nil { 2319 return out, metadata, &smithy.SerializationError{Err: err} 2320 } 2321 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2322 2323 bodyWriter := bytes.NewBuffer(nil) 2324 bodyEncoder := query.NewEncoder(bodyWriter) 2325 body := bodyEncoder.Object() 2326 body.Key("Action").String("ListVerifiedEmailAddresses") 2327 body.Key("Version").String("2010-12-01") 2328 2329 err = bodyEncoder.Encode() 2330 if err != nil { 2331 return out, metadata, &smithy.SerializationError{Err: err} 2332 } 2333 2334 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2335 return out, metadata, &smithy.SerializationError{Err: err} 2336 } 2337 2338 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2339 return out, metadata, &smithy.SerializationError{Err: err} 2340 } 2341 in.Request = request 2342 2343 return next.HandleSerialize(ctx, in) 2344} 2345 2346type awsAwsquery_serializeOpPutConfigurationSetDeliveryOptions struct { 2347} 2348 2349func (*awsAwsquery_serializeOpPutConfigurationSetDeliveryOptions) ID() string { 2350 return "OperationSerializer" 2351} 2352 2353func (m *awsAwsquery_serializeOpPutConfigurationSetDeliveryOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2354 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2355) { 2356 request, ok := in.Request.(*smithyhttp.Request) 2357 if !ok { 2358 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2359 } 2360 2361 input, ok := in.Parameters.(*PutConfigurationSetDeliveryOptionsInput) 2362 _ = input 2363 if !ok { 2364 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2365 } 2366 2367 request.Request.URL.Path = "/" 2368 request.Request.Method = "POST" 2369 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2370 if err != nil { 2371 return out, metadata, &smithy.SerializationError{Err: err} 2372 } 2373 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2374 2375 bodyWriter := bytes.NewBuffer(nil) 2376 bodyEncoder := query.NewEncoder(bodyWriter) 2377 body := bodyEncoder.Object() 2378 body.Key("Action").String("PutConfigurationSetDeliveryOptions") 2379 body.Key("Version").String("2010-12-01") 2380 2381 if err := awsAwsquery_serializeOpDocumentPutConfigurationSetDeliveryOptionsInput(input, bodyEncoder.Value); err != nil { 2382 return out, metadata, &smithy.SerializationError{Err: err} 2383 } 2384 2385 err = bodyEncoder.Encode() 2386 if err != nil { 2387 return out, metadata, &smithy.SerializationError{Err: err} 2388 } 2389 2390 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2391 return out, metadata, &smithy.SerializationError{Err: err} 2392 } 2393 2394 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2395 return out, metadata, &smithy.SerializationError{Err: err} 2396 } 2397 in.Request = request 2398 2399 return next.HandleSerialize(ctx, in) 2400} 2401 2402type awsAwsquery_serializeOpPutIdentityPolicy struct { 2403} 2404 2405func (*awsAwsquery_serializeOpPutIdentityPolicy) ID() string { 2406 return "OperationSerializer" 2407} 2408 2409func (m *awsAwsquery_serializeOpPutIdentityPolicy) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2410 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2411) { 2412 request, ok := in.Request.(*smithyhttp.Request) 2413 if !ok { 2414 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2415 } 2416 2417 input, ok := in.Parameters.(*PutIdentityPolicyInput) 2418 _ = input 2419 if !ok { 2420 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2421 } 2422 2423 request.Request.URL.Path = "/" 2424 request.Request.Method = "POST" 2425 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2426 if err != nil { 2427 return out, metadata, &smithy.SerializationError{Err: err} 2428 } 2429 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2430 2431 bodyWriter := bytes.NewBuffer(nil) 2432 bodyEncoder := query.NewEncoder(bodyWriter) 2433 body := bodyEncoder.Object() 2434 body.Key("Action").String("PutIdentityPolicy") 2435 body.Key("Version").String("2010-12-01") 2436 2437 if err := awsAwsquery_serializeOpDocumentPutIdentityPolicyInput(input, bodyEncoder.Value); err != nil { 2438 return out, metadata, &smithy.SerializationError{Err: err} 2439 } 2440 2441 err = bodyEncoder.Encode() 2442 if err != nil { 2443 return out, metadata, &smithy.SerializationError{Err: err} 2444 } 2445 2446 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2447 return out, metadata, &smithy.SerializationError{Err: err} 2448 } 2449 2450 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2451 return out, metadata, &smithy.SerializationError{Err: err} 2452 } 2453 in.Request = request 2454 2455 return next.HandleSerialize(ctx, in) 2456} 2457 2458type awsAwsquery_serializeOpReorderReceiptRuleSet struct { 2459} 2460 2461func (*awsAwsquery_serializeOpReorderReceiptRuleSet) ID() string { 2462 return "OperationSerializer" 2463} 2464 2465func (m *awsAwsquery_serializeOpReorderReceiptRuleSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2466 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2467) { 2468 request, ok := in.Request.(*smithyhttp.Request) 2469 if !ok { 2470 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2471 } 2472 2473 input, ok := in.Parameters.(*ReorderReceiptRuleSetInput) 2474 _ = input 2475 if !ok { 2476 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2477 } 2478 2479 request.Request.URL.Path = "/" 2480 request.Request.Method = "POST" 2481 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2482 if err != nil { 2483 return out, metadata, &smithy.SerializationError{Err: err} 2484 } 2485 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2486 2487 bodyWriter := bytes.NewBuffer(nil) 2488 bodyEncoder := query.NewEncoder(bodyWriter) 2489 body := bodyEncoder.Object() 2490 body.Key("Action").String("ReorderReceiptRuleSet") 2491 body.Key("Version").String("2010-12-01") 2492 2493 if err := awsAwsquery_serializeOpDocumentReorderReceiptRuleSetInput(input, bodyEncoder.Value); err != nil { 2494 return out, metadata, &smithy.SerializationError{Err: err} 2495 } 2496 2497 err = bodyEncoder.Encode() 2498 if err != nil { 2499 return out, metadata, &smithy.SerializationError{Err: err} 2500 } 2501 2502 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2503 return out, metadata, &smithy.SerializationError{Err: err} 2504 } 2505 2506 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2507 return out, metadata, &smithy.SerializationError{Err: err} 2508 } 2509 in.Request = request 2510 2511 return next.HandleSerialize(ctx, in) 2512} 2513 2514type awsAwsquery_serializeOpSendBounce struct { 2515} 2516 2517func (*awsAwsquery_serializeOpSendBounce) ID() string { 2518 return "OperationSerializer" 2519} 2520 2521func (m *awsAwsquery_serializeOpSendBounce) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2522 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2523) { 2524 request, ok := in.Request.(*smithyhttp.Request) 2525 if !ok { 2526 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2527 } 2528 2529 input, ok := in.Parameters.(*SendBounceInput) 2530 _ = input 2531 if !ok { 2532 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2533 } 2534 2535 request.Request.URL.Path = "/" 2536 request.Request.Method = "POST" 2537 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2538 if err != nil { 2539 return out, metadata, &smithy.SerializationError{Err: err} 2540 } 2541 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2542 2543 bodyWriter := bytes.NewBuffer(nil) 2544 bodyEncoder := query.NewEncoder(bodyWriter) 2545 body := bodyEncoder.Object() 2546 body.Key("Action").String("SendBounce") 2547 body.Key("Version").String("2010-12-01") 2548 2549 if err := awsAwsquery_serializeOpDocumentSendBounceInput(input, bodyEncoder.Value); err != nil { 2550 return out, metadata, &smithy.SerializationError{Err: err} 2551 } 2552 2553 err = bodyEncoder.Encode() 2554 if err != nil { 2555 return out, metadata, &smithy.SerializationError{Err: err} 2556 } 2557 2558 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2559 return out, metadata, &smithy.SerializationError{Err: err} 2560 } 2561 2562 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2563 return out, metadata, &smithy.SerializationError{Err: err} 2564 } 2565 in.Request = request 2566 2567 return next.HandleSerialize(ctx, in) 2568} 2569 2570type awsAwsquery_serializeOpSendBulkTemplatedEmail struct { 2571} 2572 2573func (*awsAwsquery_serializeOpSendBulkTemplatedEmail) ID() string { 2574 return "OperationSerializer" 2575} 2576 2577func (m *awsAwsquery_serializeOpSendBulkTemplatedEmail) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2578 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2579) { 2580 request, ok := in.Request.(*smithyhttp.Request) 2581 if !ok { 2582 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2583 } 2584 2585 input, ok := in.Parameters.(*SendBulkTemplatedEmailInput) 2586 _ = input 2587 if !ok { 2588 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2589 } 2590 2591 request.Request.URL.Path = "/" 2592 request.Request.Method = "POST" 2593 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2594 if err != nil { 2595 return out, metadata, &smithy.SerializationError{Err: err} 2596 } 2597 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2598 2599 bodyWriter := bytes.NewBuffer(nil) 2600 bodyEncoder := query.NewEncoder(bodyWriter) 2601 body := bodyEncoder.Object() 2602 body.Key("Action").String("SendBulkTemplatedEmail") 2603 body.Key("Version").String("2010-12-01") 2604 2605 if err := awsAwsquery_serializeOpDocumentSendBulkTemplatedEmailInput(input, bodyEncoder.Value); err != nil { 2606 return out, metadata, &smithy.SerializationError{Err: err} 2607 } 2608 2609 err = bodyEncoder.Encode() 2610 if err != nil { 2611 return out, metadata, &smithy.SerializationError{Err: err} 2612 } 2613 2614 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2615 return out, metadata, &smithy.SerializationError{Err: err} 2616 } 2617 2618 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2619 return out, metadata, &smithy.SerializationError{Err: err} 2620 } 2621 in.Request = request 2622 2623 return next.HandleSerialize(ctx, in) 2624} 2625 2626type awsAwsquery_serializeOpSendCustomVerificationEmail struct { 2627} 2628 2629func (*awsAwsquery_serializeOpSendCustomVerificationEmail) ID() string { 2630 return "OperationSerializer" 2631} 2632 2633func (m *awsAwsquery_serializeOpSendCustomVerificationEmail) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2634 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2635) { 2636 request, ok := in.Request.(*smithyhttp.Request) 2637 if !ok { 2638 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2639 } 2640 2641 input, ok := in.Parameters.(*SendCustomVerificationEmailInput) 2642 _ = input 2643 if !ok { 2644 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2645 } 2646 2647 request.Request.URL.Path = "/" 2648 request.Request.Method = "POST" 2649 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2650 if err != nil { 2651 return out, metadata, &smithy.SerializationError{Err: err} 2652 } 2653 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2654 2655 bodyWriter := bytes.NewBuffer(nil) 2656 bodyEncoder := query.NewEncoder(bodyWriter) 2657 body := bodyEncoder.Object() 2658 body.Key("Action").String("SendCustomVerificationEmail") 2659 body.Key("Version").String("2010-12-01") 2660 2661 if err := awsAwsquery_serializeOpDocumentSendCustomVerificationEmailInput(input, bodyEncoder.Value); err != nil { 2662 return out, metadata, &smithy.SerializationError{Err: err} 2663 } 2664 2665 err = bodyEncoder.Encode() 2666 if err != nil { 2667 return out, metadata, &smithy.SerializationError{Err: err} 2668 } 2669 2670 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2671 return out, metadata, &smithy.SerializationError{Err: err} 2672 } 2673 2674 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2675 return out, metadata, &smithy.SerializationError{Err: err} 2676 } 2677 in.Request = request 2678 2679 return next.HandleSerialize(ctx, in) 2680} 2681 2682type awsAwsquery_serializeOpSendEmail struct { 2683} 2684 2685func (*awsAwsquery_serializeOpSendEmail) ID() string { 2686 return "OperationSerializer" 2687} 2688 2689func (m *awsAwsquery_serializeOpSendEmail) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2690 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2691) { 2692 request, ok := in.Request.(*smithyhttp.Request) 2693 if !ok { 2694 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2695 } 2696 2697 input, ok := in.Parameters.(*SendEmailInput) 2698 _ = input 2699 if !ok { 2700 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2701 } 2702 2703 request.Request.URL.Path = "/" 2704 request.Request.Method = "POST" 2705 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2706 if err != nil { 2707 return out, metadata, &smithy.SerializationError{Err: err} 2708 } 2709 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2710 2711 bodyWriter := bytes.NewBuffer(nil) 2712 bodyEncoder := query.NewEncoder(bodyWriter) 2713 body := bodyEncoder.Object() 2714 body.Key("Action").String("SendEmail") 2715 body.Key("Version").String("2010-12-01") 2716 2717 if err := awsAwsquery_serializeOpDocumentSendEmailInput(input, bodyEncoder.Value); err != nil { 2718 return out, metadata, &smithy.SerializationError{Err: err} 2719 } 2720 2721 err = bodyEncoder.Encode() 2722 if err != nil { 2723 return out, metadata, &smithy.SerializationError{Err: err} 2724 } 2725 2726 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2727 return out, metadata, &smithy.SerializationError{Err: err} 2728 } 2729 2730 if request.Request, err = httpBindingEncoder.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} 2737 2738type awsAwsquery_serializeOpSendRawEmail struct { 2739} 2740 2741func (*awsAwsquery_serializeOpSendRawEmail) ID() string { 2742 return "OperationSerializer" 2743} 2744 2745func (m *awsAwsquery_serializeOpSendRawEmail) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2746 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2747) { 2748 request, ok := in.Request.(*smithyhttp.Request) 2749 if !ok { 2750 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2751 } 2752 2753 input, ok := in.Parameters.(*SendRawEmailInput) 2754 _ = input 2755 if !ok { 2756 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2757 } 2758 2759 request.Request.URL.Path = "/" 2760 request.Request.Method = "POST" 2761 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2762 if err != nil { 2763 return out, metadata, &smithy.SerializationError{Err: err} 2764 } 2765 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2766 2767 bodyWriter := bytes.NewBuffer(nil) 2768 bodyEncoder := query.NewEncoder(bodyWriter) 2769 body := bodyEncoder.Object() 2770 body.Key("Action").String("SendRawEmail") 2771 body.Key("Version").String("2010-12-01") 2772 2773 if err := awsAwsquery_serializeOpDocumentSendRawEmailInput(input, bodyEncoder.Value); err != nil { 2774 return out, metadata, &smithy.SerializationError{Err: err} 2775 } 2776 2777 err = bodyEncoder.Encode() 2778 if err != nil { 2779 return out, metadata, &smithy.SerializationError{Err: err} 2780 } 2781 2782 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2783 return out, metadata, &smithy.SerializationError{Err: err} 2784 } 2785 2786 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2787 return out, metadata, &smithy.SerializationError{Err: err} 2788 } 2789 in.Request = request 2790 2791 return next.HandleSerialize(ctx, in) 2792} 2793 2794type awsAwsquery_serializeOpSendTemplatedEmail struct { 2795} 2796 2797func (*awsAwsquery_serializeOpSendTemplatedEmail) ID() string { 2798 return "OperationSerializer" 2799} 2800 2801func (m *awsAwsquery_serializeOpSendTemplatedEmail) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2802 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2803) { 2804 request, ok := in.Request.(*smithyhttp.Request) 2805 if !ok { 2806 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2807 } 2808 2809 input, ok := in.Parameters.(*SendTemplatedEmailInput) 2810 _ = input 2811 if !ok { 2812 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2813 } 2814 2815 request.Request.URL.Path = "/" 2816 request.Request.Method = "POST" 2817 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2818 if err != nil { 2819 return out, metadata, &smithy.SerializationError{Err: err} 2820 } 2821 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2822 2823 bodyWriter := bytes.NewBuffer(nil) 2824 bodyEncoder := query.NewEncoder(bodyWriter) 2825 body := bodyEncoder.Object() 2826 body.Key("Action").String("SendTemplatedEmail") 2827 body.Key("Version").String("2010-12-01") 2828 2829 if err := awsAwsquery_serializeOpDocumentSendTemplatedEmailInput(input, bodyEncoder.Value); err != nil { 2830 return out, metadata, &smithy.SerializationError{Err: err} 2831 } 2832 2833 err = bodyEncoder.Encode() 2834 if err != nil { 2835 return out, metadata, &smithy.SerializationError{Err: err} 2836 } 2837 2838 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2839 return out, metadata, &smithy.SerializationError{Err: err} 2840 } 2841 2842 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2843 return out, metadata, &smithy.SerializationError{Err: err} 2844 } 2845 in.Request = request 2846 2847 return next.HandleSerialize(ctx, in) 2848} 2849 2850type awsAwsquery_serializeOpSetActiveReceiptRuleSet struct { 2851} 2852 2853func (*awsAwsquery_serializeOpSetActiveReceiptRuleSet) ID() string { 2854 return "OperationSerializer" 2855} 2856 2857func (m *awsAwsquery_serializeOpSetActiveReceiptRuleSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2858 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2859) { 2860 request, ok := in.Request.(*smithyhttp.Request) 2861 if !ok { 2862 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2863 } 2864 2865 input, ok := in.Parameters.(*SetActiveReceiptRuleSetInput) 2866 _ = input 2867 if !ok { 2868 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2869 } 2870 2871 request.Request.URL.Path = "/" 2872 request.Request.Method = "POST" 2873 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2874 if err != nil { 2875 return out, metadata, &smithy.SerializationError{Err: err} 2876 } 2877 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2878 2879 bodyWriter := bytes.NewBuffer(nil) 2880 bodyEncoder := query.NewEncoder(bodyWriter) 2881 body := bodyEncoder.Object() 2882 body.Key("Action").String("SetActiveReceiptRuleSet") 2883 body.Key("Version").String("2010-12-01") 2884 2885 if err := awsAwsquery_serializeOpDocumentSetActiveReceiptRuleSetInput(input, bodyEncoder.Value); err != nil { 2886 return out, metadata, &smithy.SerializationError{Err: err} 2887 } 2888 2889 err = bodyEncoder.Encode() 2890 if err != nil { 2891 return out, metadata, &smithy.SerializationError{Err: err} 2892 } 2893 2894 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2895 return out, metadata, &smithy.SerializationError{Err: err} 2896 } 2897 2898 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2899 return out, metadata, &smithy.SerializationError{Err: err} 2900 } 2901 in.Request = request 2902 2903 return next.HandleSerialize(ctx, in) 2904} 2905 2906type awsAwsquery_serializeOpSetIdentityDkimEnabled struct { 2907} 2908 2909func (*awsAwsquery_serializeOpSetIdentityDkimEnabled) ID() string { 2910 return "OperationSerializer" 2911} 2912 2913func (m *awsAwsquery_serializeOpSetIdentityDkimEnabled) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2914 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2915) { 2916 request, ok := in.Request.(*smithyhttp.Request) 2917 if !ok { 2918 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2919 } 2920 2921 input, ok := in.Parameters.(*SetIdentityDkimEnabledInput) 2922 _ = input 2923 if !ok { 2924 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2925 } 2926 2927 request.Request.URL.Path = "/" 2928 request.Request.Method = "POST" 2929 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2930 if err != nil { 2931 return out, metadata, &smithy.SerializationError{Err: err} 2932 } 2933 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2934 2935 bodyWriter := bytes.NewBuffer(nil) 2936 bodyEncoder := query.NewEncoder(bodyWriter) 2937 body := bodyEncoder.Object() 2938 body.Key("Action").String("SetIdentityDkimEnabled") 2939 body.Key("Version").String("2010-12-01") 2940 2941 if err := awsAwsquery_serializeOpDocumentSetIdentityDkimEnabledInput(input, bodyEncoder.Value); err != nil { 2942 return out, metadata, &smithy.SerializationError{Err: err} 2943 } 2944 2945 err = bodyEncoder.Encode() 2946 if err != nil { 2947 return out, metadata, &smithy.SerializationError{Err: err} 2948 } 2949 2950 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 2951 return out, metadata, &smithy.SerializationError{Err: err} 2952 } 2953 2954 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 2955 return out, metadata, &smithy.SerializationError{Err: err} 2956 } 2957 in.Request = request 2958 2959 return next.HandleSerialize(ctx, in) 2960} 2961 2962type awsAwsquery_serializeOpSetIdentityFeedbackForwardingEnabled struct { 2963} 2964 2965func (*awsAwsquery_serializeOpSetIdentityFeedbackForwardingEnabled) ID() string { 2966 return "OperationSerializer" 2967} 2968 2969func (m *awsAwsquery_serializeOpSetIdentityFeedbackForwardingEnabled) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2970 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2971) { 2972 request, ok := in.Request.(*smithyhttp.Request) 2973 if !ok { 2974 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2975 } 2976 2977 input, ok := in.Parameters.(*SetIdentityFeedbackForwardingEnabledInput) 2978 _ = input 2979 if !ok { 2980 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2981 } 2982 2983 request.Request.URL.Path = "/" 2984 request.Request.Method = "POST" 2985 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2986 if err != nil { 2987 return out, metadata, &smithy.SerializationError{Err: err} 2988 } 2989 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 2990 2991 bodyWriter := bytes.NewBuffer(nil) 2992 bodyEncoder := query.NewEncoder(bodyWriter) 2993 body := bodyEncoder.Object() 2994 body.Key("Action").String("SetIdentityFeedbackForwardingEnabled") 2995 body.Key("Version").String("2010-12-01") 2996 2997 if err := awsAwsquery_serializeOpDocumentSetIdentityFeedbackForwardingEnabledInput(input, bodyEncoder.Value); err != nil { 2998 return out, metadata, &smithy.SerializationError{Err: err} 2999 } 3000 3001 err = bodyEncoder.Encode() 3002 if err != nil { 3003 return out, metadata, &smithy.SerializationError{Err: err} 3004 } 3005 3006 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3007 return out, metadata, &smithy.SerializationError{Err: err} 3008 } 3009 3010 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3011 return out, metadata, &smithy.SerializationError{Err: err} 3012 } 3013 in.Request = request 3014 3015 return next.HandleSerialize(ctx, in) 3016} 3017 3018type awsAwsquery_serializeOpSetIdentityHeadersInNotificationsEnabled struct { 3019} 3020 3021func (*awsAwsquery_serializeOpSetIdentityHeadersInNotificationsEnabled) ID() string { 3022 return "OperationSerializer" 3023} 3024 3025func (m *awsAwsquery_serializeOpSetIdentityHeadersInNotificationsEnabled) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3026 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3027) { 3028 request, ok := in.Request.(*smithyhttp.Request) 3029 if !ok { 3030 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3031 } 3032 3033 input, ok := in.Parameters.(*SetIdentityHeadersInNotificationsEnabledInput) 3034 _ = input 3035 if !ok { 3036 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3037 } 3038 3039 request.Request.URL.Path = "/" 3040 request.Request.Method = "POST" 3041 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3042 if err != nil { 3043 return out, metadata, &smithy.SerializationError{Err: err} 3044 } 3045 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3046 3047 bodyWriter := bytes.NewBuffer(nil) 3048 bodyEncoder := query.NewEncoder(bodyWriter) 3049 body := bodyEncoder.Object() 3050 body.Key("Action").String("SetIdentityHeadersInNotificationsEnabled") 3051 body.Key("Version").String("2010-12-01") 3052 3053 if err := awsAwsquery_serializeOpDocumentSetIdentityHeadersInNotificationsEnabledInput(input, bodyEncoder.Value); err != nil { 3054 return out, metadata, &smithy.SerializationError{Err: err} 3055 } 3056 3057 err = bodyEncoder.Encode() 3058 if err != nil { 3059 return out, metadata, &smithy.SerializationError{Err: err} 3060 } 3061 3062 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3063 return out, metadata, &smithy.SerializationError{Err: err} 3064 } 3065 3066 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3067 return out, metadata, &smithy.SerializationError{Err: err} 3068 } 3069 in.Request = request 3070 3071 return next.HandleSerialize(ctx, in) 3072} 3073 3074type awsAwsquery_serializeOpSetIdentityMailFromDomain struct { 3075} 3076 3077func (*awsAwsquery_serializeOpSetIdentityMailFromDomain) ID() string { 3078 return "OperationSerializer" 3079} 3080 3081func (m *awsAwsquery_serializeOpSetIdentityMailFromDomain) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3082 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3083) { 3084 request, ok := in.Request.(*smithyhttp.Request) 3085 if !ok { 3086 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3087 } 3088 3089 input, ok := in.Parameters.(*SetIdentityMailFromDomainInput) 3090 _ = input 3091 if !ok { 3092 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3093 } 3094 3095 request.Request.URL.Path = "/" 3096 request.Request.Method = "POST" 3097 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3098 if err != nil { 3099 return out, metadata, &smithy.SerializationError{Err: err} 3100 } 3101 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3102 3103 bodyWriter := bytes.NewBuffer(nil) 3104 bodyEncoder := query.NewEncoder(bodyWriter) 3105 body := bodyEncoder.Object() 3106 body.Key("Action").String("SetIdentityMailFromDomain") 3107 body.Key("Version").String("2010-12-01") 3108 3109 if err := awsAwsquery_serializeOpDocumentSetIdentityMailFromDomainInput(input, bodyEncoder.Value); err != nil { 3110 return out, metadata, &smithy.SerializationError{Err: err} 3111 } 3112 3113 err = bodyEncoder.Encode() 3114 if err != nil { 3115 return out, metadata, &smithy.SerializationError{Err: err} 3116 } 3117 3118 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3119 return out, metadata, &smithy.SerializationError{Err: err} 3120 } 3121 3122 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3123 return out, metadata, &smithy.SerializationError{Err: err} 3124 } 3125 in.Request = request 3126 3127 return next.HandleSerialize(ctx, in) 3128} 3129 3130type awsAwsquery_serializeOpSetIdentityNotificationTopic struct { 3131} 3132 3133func (*awsAwsquery_serializeOpSetIdentityNotificationTopic) ID() string { 3134 return "OperationSerializer" 3135} 3136 3137func (m *awsAwsquery_serializeOpSetIdentityNotificationTopic) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3138 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3139) { 3140 request, ok := in.Request.(*smithyhttp.Request) 3141 if !ok { 3142 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3143 } 3144 3145 input, ok := in.Parameters.(*SetIdentityNotificationTopicInput) 3146 _ = input 3147 if !ok { 3148 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3149 } 3150 3151 request.Request.URL.Path = "/" 3152 request.Request.Method = "POST" 3153 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3154 if err != nil { 3155 return out, metadata, &smithy.SerializationError{Err: err} 3156 } 3157 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3158 3159 bodyWriter := bytes.NewBuffer(nil) 3160 bodyEncoder := query.NewEncoder(bodyWriter) 3161 body := bodyEncoder.Object() 3162 body.Key("Action").String("SetIdentityNotificationTopic") 3163 body.Key("Version").String("2010-12-01") 3164 3165 if err := awsAwsquery_serializeOpDocumentSetIdentityNotificationTopicInput(input, bodyEncoder.Value); err != nil { 3166 return out, metadata, &smithy.SerializationError{Err: err} 3167 } 3168 3169 err = bodyEncoder.Encode() 3170 if err != nil { 3171 return out, metadata, &smithy.SerializationError{Err: err} 3172 } 3173 3174 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3175 return out, metadata, &smithy.SerializationError{Err: err} 3176 } 3177 3178 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3179 return out, metadata, &smithy.SerializationError{Err: err} 3180 } 3181 in.Request = request 3182 3183 return next.HandleSerialize(ctx, in) 3184} 3185 3186type awsAwsquery_serializeOpSetReceiptRulePosition struct { 3187} 3188 3189func (*awsAwsquery_serializeOpSetReceiptRulePosition) ID() string { 3190 return "OperationSerializer" 3191} 3192 3193func (m *awsAwsquery_serializeOpSetReceiptRulePosition) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3194 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3195) { 3196 request, ok := in.Request.(*smithyhttp.Request) 3197 if !ok { 3198 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3199 } 3200 3201 input, ok := in.Parameters.(*SetReceiptRulePositionInput) 3202 _ = input 3203 if !ok { 3204 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3205 } 3206 3207 request.Request.URL.Path = "/" 3208 request.Request.Method = "POST" 3209 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3210 if err != nil { 3211 return out, metadata, &smithy.SerializationError{Err: err} 3212 } 3213 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3214 3215 bodyWriter := bytes.NewBuffer(nil) 3216 bodyEncoder := query.NewEncoder(bodyWriter) 3217 body := bodyEncoder.Object() 3218 body.Key("Action").String("SetReceiptRulePosition") 3219 body.Key("Version").String("2010-12-01") 3220 3221 if err := awsAwsquery_serializeOpDocumentSetReceiptRulePositionInput(input, bodyEncoder.Value); err != nil { 3222 return out, metadata, &smithy.SerializationError{Err: err} 3223 } 3224 3225 err = bodyEncoder.Encode() 3226 if err != nil { 3227 return out, metadata, &smithy.SerializationError{Err: err} 3228 } 3229 3230 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3231 return out, metadata, &smithy.SerializationError{Err: err} 3232 } 3233 3234 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3235 return out, metadata, &smithy.SerializationError{Err: err} 3236 } 3237 in.Request = request 3238 3239 return next.HandleSerialize(ctx, in) 3240} 3241 3242type awsAwsquery_serializeOpTestRenderTemplate struct { 3243} 3244 3245func (*awsAwsquery_serializeOpTestRenderTemplate) ID() string { 3246 return "OperationSerializer" 3247} 3248 3249func (m *awsAwsquery_serializeOpTestRenderTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3250 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3251) { 3252 request, ok := in.Request.(*smithyhttp.Request) 3253 if !ok { 3254 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3255 } 3256 3257 input, ok := in.Parameters.(*TestRenderTemplateInput) 3258 _ = input 3259 if !ok { 3260 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3261 } 3262 3263 request.Request.URL.Path = "/" 3264 request.Request.Method = "POST" 3265 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3266 if err != nil { 3267 return out, metadata, &smithy.SerializationError{Err: err} 3268 } 3269 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3270 3271 bodyWriter := bytes.NewBuffer(nil) 3272 bodyEncoder := query.NewEncoder(bodyWriter) 3273 body := bodyEncoder.Object() 3274 body.Key("Action").String("TestRenderTemplate") 3275 body.Key("Version").String("2010-12-01") 3276 3277 if err := awsAwsquery_serializeOpDocumentTestRenderTemplateInput(input, bodyEncoder.Value); err != nil { 3278 return out, metadata, &smithy.SerializationError{Err: err} 3279 } 3280 3281 err = bodyEncoder.Encode() 3282 if err != nil { 3283 return out, metadata, &smithy.SerializationError{Err: err} 3284 } 3285 3286 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3287 return out, metadata, &smithy.SerializationError{Err: err} 3288 } 3289 3290 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3291 return out, metadata, &smithy.SerializationError{Err: err} 3292 } 3293 in.Request = request 3294 3295 return next.HandleSerialize(ctx, in) 3296} 3297 3298type awsAwsquery_serializeOpUpdateAccountSendingEnabled struct { 3299} 3300 3301func (*awsAwsquery_serializeOpUpdateAccountSendingEnabled) ID() string { 3302 return "OperationSerializer" 3303} 3304 3305func (m *awsAwsquery_serializeOpUpdateAccountSendingEnabled) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3306 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3307) { 3308 request, ok := in.Request.(*smithyhttp.Request) 3309 if !ok { 3310 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3311 } 3312 3313 input, ok := in.Parameters.(*UpdateAccountSendingEnabledInput) 3314 _ = input 3315 if !ok { 3316 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3317 } 3318 3319 request.Request.URL.Path = "/" 3320 request.Request.Method = "POST" 3321 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3322 if err != nil { 3323 return out, metadata, &smithy.SerializationError{Err: err} 3324 } 3325 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3326 3327 bodyWriter := bytes.NewBuffer(nil) 3328 bodyEncoder := query.NewEncoder(bodyWriter) 3329 body := bodyEncoder.Object() 3330 body.Key("Action").String("UpdateAccountSendingEnabled") 3331 body.Key("Version").String("2010-12-01") 3332 3333 if err := awsAwsquery_serializeOpDocumentUpdateAccountSendingEnabledInput(input, bodyEncoder.Value); err != nil { 3334 return out, metadata, &smithy.SerializationError{Err: err} 3335 } 3336 3337 err = bodyEncoder.Encode() 3338 if err != nil { 3339 return out, metadata, &smithy.SerializationError{Err: err} 3340 } 3341 3342 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3343 return out, metadata, &smithy.SerializationError{Err: err} 3344 } 3345 3346 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3347 return out, metadata, &smithy.SerializationError{Err: err} 3348 } 3349 in.Request = request 3350 3351 return next.HandleSerialize(ctx, in) 3352} 3353 3354type awsAwsquery_serializeOpUpdateConfigurationSetEventDestination struct { 3355} 3356 3357func (*awsAwsquery_serializeOpUpdateConfigurationSetEventDestination) ID() string { 3358 return "OperationSerializer" 3359} 3360 3361func (m *awsAwsquery_serializeOpUpdateConfigurationSetEventDestination) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3362 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3363) { 3364 request, ok := in.Request.(*smithyhttp.Request) 3365 if !ok { 3366 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3367 } 3368 3369 input, ok := in.Parameters.(*UpdateConfigurationSetEventDestinationInput) 3370 _ = input 3371 if !ok { 3372 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3373 } 3374 3375 request.Request.URL.Path = "/" 3376 request.Request.Method = "POST" 3377 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3378 if err != nil { 3379 return out, metadata, &smithy.SerializationError{Err: err} 3380 } 3381 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3382 3383 bodyWriter := bytes.NewBuffer(nil) 3384 bodyEncoder := query.NewEncoder(bodyWriter) 3385 body := bodyEncoder.Object() 3386 body.Key("Action").String("UpdateConfigurationSetEventDestination") 3387 body.Key("Version").String("2010-12-01") 3388 3389 if err := awsAwsquery_serializeOpDocumentUpdateConfigurationSetEventDestinationInput(input, bodyEncoder.Value); err != nil { 3390 return out, metadata, &smithy.SerializationError{Err: err} 3391 } 3392 3393 err = bodyEncoder.Encode() 3394 if err != nil { 3395 return out, metadata, &smithy.SerializationError{Err: err} 3396 } 3397 3398 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3399 return out, metadata, &smithy.SerializationError{Err: err} 3400 } 3401 3402 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3403 return out, metadata, &smithy.SerializationError{Err: err} 3404 } 3405 in.Request = request 3406 3407 return next.HandleSerialize(ctx, in) 3408} 3409 3410type awsAwsquery_serializeOpUpdateConfigurationSetReputationMetricsEnabled struct { 3411} 3412 3413func (*awsAwsquery_serializeOpUpdateConfigurationSetReputationMetricsEnabled) ID() string { 3414 return "OperationSerializer" 3415} 3416 3417func (m *awsAwsquery_serializeOpUpdateConfigurationSetReputationMetricsEnabled) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3418 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3419) { 3420 request, ok := in.Request.(*smithyhttp.Request) 3421 if !ok { 3422 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3423 } 3424 3425 input, ok := in.Parameters.(*UpdateConfigurationSetReputationMetricsEnabledInput) 3426 _ = input 3427 if !ok { 3428 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3429 } 3430 3431 request.Request.URL.Path = "/" 3432 request.Request.Method = "POST" 3433 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3434 if err != nil { 3435 return out, metadata, &smithy.SerializationError{Err: err} 3436 } 3437 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3438 3439 bodyWriter := bytes.NewBuffer(nil) 3440 bodyEncoder := query.NewEncoder(bodyWriter) 3441 body := bodyEncoder.Object() 3442 body.Key("Action").String("UpdateConfigurationSetReputationMetricsEnabled") 3443 body.Key("Version").String("2010-12-01") 3444 3445 if err := awsAwsquery_serializeOpDocumentUpdateConfigurationSetReputationMetricsEnabledInput(input, bodyEncoder.Value); err != nil { 3446 return out, metadata, &smithy.SerializationError{Err: err} 3447 } 3448 3449 err = bodyEncoder.Encode() 3450 if err != nil { 3451 return out, metadata, &smithy.SerializationError{Err: err} 3452 } 3453 3454 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3455 return out, metadata, &smithy.SerializationError{Err: err} 3456 } 3457 3458 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3459 return out, metadata, &smithy.SerializationError{Err: err} 3460 } 3461 in.Request = request 3462 3463 return next.HandleSerialize(ctx, in) 3464} 3465 3466type awsAwsquery_serializeOpUpdateConfigurationSetSendingEnabled struct { 3467} 3468 3469func (*awsAwsquery_serializeOpUpdateConfigurationSetSendingEnabled) ID() string { 3470 return "OperationSerializer" 3471} 3472 3473func (m *awsAwsquery_serializeOpUpdateConfigurationSetSendingEnabled) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3474 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3475) { 3476 request, ok := in.Request.(*smithyhttp.Request) 3477 if !ok { 3478 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3479 } 3480 3481 input, ok := in.Parameters.(*UpdateConfigurationSetSendingEnabledInput) 3482 _ = input 3483 if !ok { 3484 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3485 } 3486 3487 request.Request.URL.Path = "/" 3488 request.Request.Method = "POST" 3489 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3490 if err != nil { 3491 return out, metadata, &smithy.SerializationError{Err: err} 3492 } 3493 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3494 3495 bodyWriter := bytes.NewBuffer(nil) 3496 bodyEncoder := query.NewEncoder(bodyWriter) 3497 body := bodyEncoder.Object() 3498 body.Key("Action").String("UpdateConfigurationSetSendingEnabled") 3499 body.Key("Version").String("2010-12-01") 3500 3501 if err := awsAwsquery_serializeOpDocumentUpdateConfigurationSetSendingEnabledInput(input, bodyEncoder.Value); err != nil { 3502 return out, metadata, &smithy.SerializationError{Err: err} 3503 } 3504 3505 err = bodyEncoder.Encode() 3506 if err != nil { 3507 return out, metadata, &smithy.SerializationError{Err: err} 3508 } 3509 3510 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3511 return out, metadata, &smithy.SerializationError{Err: err} 3512 } 3513 3514 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3515 return out, metadata, &smithy.SerializationError{Err: err} 3516 } 3517 in.Request = request 3518 3519 return next.HandleSerialize(ctx, in) 3520} 3521 3522type awsAwsquery_serializeOpUpdateConfigurationSetTrackingOptions struct { 3523} 3524 3525func (*awsAwsquery_serializeOpUpdateConfigurationSetTrackingOptions) ID() string { 3526 return "OperationSerializer" 3527} 3528 3529func (m *awsAwsquery_serializeOpUpdateConfigurationSetTrackingOptions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3530 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3531) { 3532 request, ok := in.Request.(*smithyhttp.Request) 3533 if !ok { 3534 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3535 } 3536 3537 input, ok := in.Parameters.(*UpdateConfigurationSetTrackingOptionsInput) 3538 _ = input 3539 if !ok { 3540 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3541 } 3542 3543 request.Request.URL.Path = "/" 3544 request.Request.Method = "POST" 3545 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3546 if err != nil { 3547 return out, metadata, &smithy.SerializationError{Err: err} 3548 } 3549 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3550 3551 bodyWriter := bytes.NewBuffer(nil) 3552 bodyEncoder := query.NewEncoder(bodyWriter) 3553 body := bodyEncoder.Object() 3554 body.Key("Action").String("UpdateConfigurationSetTrackingOptions") 3555 body.Key("Version").String("2010-12-01") 3556 3557 if err := awsAwsquery_serializeOpDocumentUpdateConfigurationSetTrackingOptionsInput(input, bodyEncoder.Value); err != nil { 3558 return out, metadata, &smithy.SerializationError{Err: err} 3559 } 3560 3561 err = bodyEncoder.Encode() 3562 if err != nil { 3563 return out, metadata, &smithy.SerializationError{Err: err} 3564 } 3565 3566 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3567 return out, metadata, &smithy.SerializationError{Err: err} 3568 } 3569 3570 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3571 return out, metadata, &smithy.SerializationError{Err: err} 3572 } 3573 in.Request = request 3574 3575 return next.HandleSerialize(ctx, in) 3576} 3577 3578type awsAwsquery_serializeOpUpdateCustomVerificationEmailTemplate struct { 3579} 3580 3581func (*awsAwsquery_serializeOpUpdateCustomVerificationEmailTemplate) ID() string { 3582 return "OperationSerializer" 3583} 3584 3585func (m *awsAwsquery_serializeOpUpdateCustomVerificationEmailTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3586 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3587) { 3588 request, ok := in.Request.(*smithyhttp.Request) 3589 if !ok { 3590 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3591 } 3592 3593 input, ok := in.Parameters.(*UpdateCustomVerificationEmailTemplateInput) 3594 _ = input 3595 if !ok { 3596 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3597 } 3598 3599 request.Request.URL.Path = "/" 3600 request.Request.Method = "POST" 3601 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3602 if err != nil { 3603 return out, metadata, &smithy.SerializationError{Err: err} 3604 } 3605 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3606 3607 bodyWriter := bytes.NewBuffer(nil) 3608 bodyEncoder := query.NewEncoder(bodyWriter) 3609 body := bodyEncoder.Object() 3610 body.Key("Action").String("UpdateCustomVerificationEmailTemplate") 3611 body.Key("Version").String("2010-12-01") 3612 3613 if err := awsAwsquery_serializeOpDocumentUpdateCustomVerificationEmailTemplateInput(input, bodyEncoder.Value); err != nil { 3614 return out, metadata, &smithy.SerializationError{Err: err} 3615 } 3616 3617 err = bodyEncoder.Encode() 3618 if err != nil { 3619 return out, metadata, &smithy.SerializationError{Err: err} 3620 } 3621 3622 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3623 return out, metadata, &smithy.SerializationError{Err: err} 3624 } 3625 3626 if request.Request, err = httpBindingEncoder.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} 3633 3634type awsAwsquery_serializeOpUpdateReceiptRule struct { 3635} 3636 3637func (*awsAwsquery_serializeOpUpdateReceiptRule) ID() string { 3638 return "OperationSerializer" 3639} 3640 3641func (m *awsAwsquery_serializeOpUpdateReceiptRule) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3642 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3643) { 3644 request, ok := in.Request.(*smithyhttp.Request) 3645 if !ok { 3646 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3647 } 3648 3649 input, ok := in.Parameters.(*UpdateReceiptRuleInput) 3650 _ = input 3651 if !ok { 3652 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3653 } 3654 3655 request.Request.URL.Path = "/" 3656 request.Request.Method = "POST" 3657 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3658 if err != nil { 3659 return out, metadata, &smithy.SerializationError{Err: err} 3660 } 3661 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3662 3663 bodyWriter := bytes.NewBuffer(nil) 3664 bodyEncoder := query.NewEncoder(bodyWriter) 3665 body := bodyEncoder.Object() 3666 body.Key("Action").String("UpdateReceiptRule") 3667 body.Key("Version").String("2010-12-01") 3668 3669 if err := awsAwsquery_serializeOpDocumentUpdateReceiptRuleInput(input, bodyEncoder.Value); err != nil { 3670 return out, metadata, &smithy.SerializationError{Err: err} 3671 } 3672 3673 err = bodyEncoder.Encode() 3674 if err != nil { 3675 return out, metadata, &smithy.SerializationError{Err: err} 3676 } 3677 3678 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3679 return out, metadata, &smithy.SerializationError{Err: err} 3680 } 3681 3682 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3683 return out, metadata, &smithy.SerializationError{Err: err} 3684 } 3685 in.Request = request 3686 3687 return next.HandleSerialize(ctx, in) 3688} 3689 3690type awsAwsquery_serializeOpUpdateTemplate struct { 3691} 3692 3693func (*awsAwsquery_serializeOpUpdateTemplate) ID() string { 3694 return "OperationSerializer" 3695} 3696 3697func (m *awsAwsquery_serializeOpUpdateTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3698 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3699) { 3700 request, ok := in.Request.(*smithyhttp.Request) 3701 if !ok { 3702 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3703 } 3704 3705 input, ok := in.Parameters.(*UpdateTemplateInput) 3706 _ = input 3707 if !ok { 3708 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3709 } 3710 3711 request.Request.URL.Path = "/" 3712 request.Request.Method = "POST" 3713 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3714 if err != nil { 3715 return out, metadata, &smithy.SerializationError{Err: err} 3716 } 3717 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3718 3719 bodyWriter := bytes.NewBuffer(nil) 3720 bodyEncoder := query.NewEncoder(bodyWriter) 3721 body := bodyEncoder.Object() 3722 body.Key("Action").String("UpdateTemplate") 3723 body.Key("Version").String("2010-12-01") 3724 3725 if err := awsAwsquery_serializeOpDocumentUpdateTemplateInput(input, bodyEncoder.Value); err != nil { 3726 return out, metadata, &smithy.SerializationError{Err: err} 3727 } 3728 3729 err = bodyEncoder.Encode() 3730 if err != nil { 3731 return out, metadata, &smithy.SerializationError{Err: err} 3732 } 3733 3734 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3735 return out, metadata, &smithy.SerializationError{Err: err} 3736 } 3737 3738 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3739 return out, metadata, &smithy.SerializationError{Err: err} 3740 } 3741 in.Request = request 3742 3743 return next.HandleSerialize(ctx, in) 3744} 3745 3746type awsAwsquery_serializeOpVerifyDomainDkim struct { 3747} 3748 3749func (*awsAwsquery_serializeOpVerifyDomainDkim) ID() string { 3750 return "OperationSerializer" 3751} 3752 3753func (m *awsAwsquery_serializeOpVerifyDomainDkim) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3754 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3755) { 3756 request, ok := in.Request.(*smithyhttp.Request) 3757 if !ok { 3758 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3759 } 3760 3761 input, ok := in.Parameters.(*VerifyDomainDkimInput) 3762 _ = input 3763 if !ok { 3764 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3765 } 3766 3767 request.Request.URL.Path = "/" 3768 request.Request.Method = "POST" 3769 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3770 if err != nil { 3771 return out, metadata, &smithy.SerializationError{Err: err} 3772 } 3773 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3774 3775 bodyWriter := bytes.NewBuffer(nil) 3776 bodyEncoder := query.NewEncoder(bodyWriter) 3777 body := bodyEncoder.Object() 3778 body.Key("Action").String("VerifyDomainDkim") 3779 body.Key("Version").String("2010-12-01") 3780 3781 if err := awsAwsquery_serializeOpDocumentVerifyDomainDkimInput(input, bodyEncoder.Value); err != nil { 3782 return out, metadata, &smithy.SerializationError{Err: err} 3783 } 3784 3785 err = bodyEncoder.Encode() 3786 if err != nil { 3787 return out, metadata, &smithy.SerializationError{Err: err} 3788 } 3789 3790 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3791 return out, metadata, &smithy.SerializationError{Err: err} 3792 } 3793 3794 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3795 return out, metadata, &smithy.SerializationError{Err: err} 3796 } 3797 in.Request = request 3798 3799 return next.HandleSerialize(ctx, in) 3800} 3801 3802type awsAwsquery_serializeOpVerifyDomainIdentity struct { 3803} 3804 3805func (*awsAwsquery_serializeOpVerifyDomainIdentity) ID() string { 3806 return "OperationSerializer" 3807} 3808 3809func (m *awsAwsquery_serializeOpVerifyDomainIdentity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3810 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3811) { 3812 request, ok := in.Request.(*smithyhttp.Request) 3813 if !ok { 3814 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3815 } 3816 3817 input, ok := in.Parameters.(*VerifyDomainIdentityInput) 3818 _ = input 3819 if !ok { 3820 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3821 } 3822 3823 request.Request.URL.Path = "/" 3824 request.Request.Method = "POST" 3825 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3826 if err != nil { 3827 return out, metadata, &smithy.SerializationError{Err: err} 3828 } 3829 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3830 3831 bodyWriter := bytes.NewBuffer(nil) 3832 bodyEncoder := query.NewEncoder(bodyWriter) 3833 body := bodyEncoder.Object() 3834 body.Key("Action").String("VerifyDomainIdentity") 3835 body.Key("Version").String("2010-12-01") 3836 3837 if err := awsAwsquery_serializeOpDocumentVerifyDomainIdentityInput(input, bodyEncoder.Value); err != nil { 3838 return out, metadata, &smithy.SerializationError{Err: err} 3839 } 3840 3841 err = bodyEncoder.Encode() 3842 if err != nil { 3843 return out, metadata, &smithy.SerializationError{Err: err} 3844 } 3845 3846 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3847 return out, metadata, &smithy.SerializationError{Err: err} 3848 } 3849 3850 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3851 return out, metadata, &smithy.SerializationError{Err: err} 3852 } 3853 in.Request = request 3854 3855 return next.HandleSerialize(ctx, in) 3856} 3857 3858type awsAwsquery_serializeOpVerifyEmailAddress struct { 3859} 3860 3861func (*awsAwsquery_serializeOpVerifyEmailAddress) ID() string { 3862 return "OperationSerializer" 3863} 3864 3865func (m *awsAwsquery_serializeOpVerifyEmailAddress) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3866 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3867) { 3868 request, ok := in.Request.(*smithyhttp.Request) 3869 if !ok { 3870 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3871 } 3872 3873 input, ok := in.Parameters.(*VerifyEmailAddressInput) 3874 _ = input 3875 if !ok { 3876 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3877 } 3878 3879 request.Request.URL.Path = "/" 3880 request.Request.Method = "POST" 3881 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3882 if err != nil { 3883 return out, metadata, &smithy.SerializationError{Err: err} 3884 } 3885 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3886 3887 bodyWriter := bytes.NewBuffer(nil) 3888 bodyEncoder := query.NewEncoder(bodyWriter) 3889 body := bodyEncoder.Object() 3890 body.Key("Action").String("VerifyEmailAddress") 3891 body.Key("Version").String("2010-12-01") 3892 3893 if err := awsAwsquery_serializeOpDocumentVerifyEmailAddressInput(input, bodyEncoder.Value); err != nil { 3894 return out, metadata, &smithy.SerializationError{Err: err} 3895 } 3896 3897 err = bodyEncoder.Encode() 3898 if err != nil { 3899 return out, metadata, &smithy.SerializationError{Err: err} 3900 } 3901 3902 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3903 return out, metadata, &smithy.SerializationError{Err: err} 3904 } 3905 3906 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3907 return out, metadata, &smithy.SerializationError{Err: err} 3908 } 3909 in.Request = request 3910 3911 return next.HandleSerialize(ctx, in) 3912} 3913 3914type awsAwsquery_serializeOpVerifyEmailIdentity struct { 3915} 3916 3917func (*awsAwsquery_serializeOpVerifyEmailIdentity) ID() string { 3918 return "OperationSerializer" 3919} 3920 3921func (m *awsAwsquery_serializeOpVerifyEmailIdentity) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 3922 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 3923) { 3924 request, ok := in.Request.(*smithyhttp.Request) 3925 if !ok { 3926 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 3927 } 3928 3929 input, ok := in.Parameters.(*VerifyEmailIdentityInput) 3930 _ = input 3931 if !ok { 3932 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 3933 } 3934 3935 request.Request.URL.Path = "/" 3936 request.Request.Method = "POST" 3937 httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 3938 if err != nil { 3939 return out, metadata, &smithy.SerializationError{Err: err} 3940 } 3941 httpBindingEncoder.SetHeader("Content-Type").String("application/x-www-form-urlencoded") 3942 3943 bodyWriter := bytes.NewBuffer(nil) 3944 bodyEncoder := query.NewEncoder(bodyWriter) 3945 body := bodyEncoder.Object() 3946 body.Key("Action").String("VerifyEmailIdentity") 3947 body.Key("Version").String("2010-12-01") 3948 3949 if err := awsAwsquery_serializeOpDocumentVerifyEmailIdentityInput(input, bodyEncoder.Value); err != nil { 3950 return out, metadata, &smithy.SerializationError{Err: err} 3951 } 3952 3953 err = bodyEncoder.Encode() 3954 if err != nil { 3955 return out, metadata, &smithy.SerializationError{Err: err} 3956 } 3957 3958 if request, err = request.SetStream(bytes.NewReader(bodyWriter.Bytes())); err != nil { 3959 return out, metadata, &smithy.SerializationError{Err: err} 3960 } 3961 3962 if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil { 3963 return out, metadata, &smithy.SerializationError{Err: err} 3964 } 3965 in.Request = request 3966 3967 return next.HandleSerialize(ctx, in) 3968} 3969func awsAwsquery_serializeDocumentAddHeaderAction(v *types.AddHeaderAction, value query.Value) error { 3970 object := value.Object() 3971 _ = object 3972 3973 if v.HeaderName != nil { 3974 objectKey := object.Key("HeaderName") 3975 objectKey.String(*v.HeaderName) 3976 } 3977 3978 if v.HeaderValue != nil { 3979 objectKey := object.Key("HeaderValue") 3980 objectKey.String(*v.HeaderValue) 3981 } 3982 3983 return nil 3984} 3985 3986func awsAwsquery_serializeDocumentAddressList(v []string, value query.Value) error { 3987 if len(v) == 0 { 3988 return nil 3989 } 3990 array := value.Array("member") 3991 3992 for i := range v { 3993 av := array.Value() 3994 av.String(v[i]) 3995 } 3996 return nil 3997} 3998 3999func awsAwsquery_serializeDocumentBody(v *types.Body, value query.Value) error { 4000 object := value.Object() 4001 _ = object 4002 4003 if v.Html != nil { 4004 objectKey := object.Key("Html") 4005 if err := awsAwsquery_serializeDocumentContent(v.Html, objectKey); err != nil { 4006 return err 4007 } 4008 } 4009 4010 if v.Text != nil { 4011 objectKey := object.Key("Text") 4012 if err := awsAwsquery_serializeDocumentContent(v.Text, objectKey); err != nil { 4013 return err 4014 } 4015 } 4016 4017 return nil 4018} 4019 4020func awsAwsquery_serializeDocumentBounceAction(v *types.BounceAction, value query.Value) error { 4021 object := value.Object() 4022 _ = object 4023 4024 if v.Message != nil { 4025 objectKey := object.Key("Message") 4026 objectKey.String(*v.Message) 4027 } 4028 4029 if v.Sender != nil { 4030 objectKey := object.Key("Sender") 4031 objectKey.String(*v.Sender) 4032 } 4033 4034 if v.SmtpReplyCode != nil { 4035 objectKey := object.Key("SmtpReplyCode") 4036 objectKey.String(*v.SmtpReplyCode) 4037 } 4038 4039 if v.StatusCode != nil { 4040 objectKey := object.Key("StatusCode") 4041 objectKey.String(*v.StatusCode) 4042 } 4043 4044 if v.TopicArn != nil { 4045 objectKey := object.Key("TopicArn") 4046 objectKey.String(*v.TopicArn) 4047 } 4048 4049 return nil 4050} 4051 4052func awsAwsquery_serializeDocumentBouncedRecipientInfo(v *types.BouncedRecipientInfo, value query.Value) error { 4053 object := value.Object() 4054 _ = object 4055 4056 if len(v.BounceType) > 0 { 4057 objectKey := object.Key("BounceType") 4058 objectKey.String(string(v.BounceType)) 4059 } 4060 4061 if v.Recipient != nil { 4062 objectKey := object.Key("Recipient") 4063 objectKey.String(*v.Recipient) 4064 } 4065 4066 if v.RecipientArn != nil { 4067 objectKey := object.Key("RecipientArn") 4068 objectKey.String(*v.RecipientArn) 4069 } 4070 4071 if v.RecipientDsnFields != nil { 4072 objectKey := object.Key("RecipientDsnFields") 4073 if err := awsAwsquery_serializeDocumentRecipientDsnFields(v.RecipientDsnFields, objectKey); err != nil { 4074 return err 4075 } 4076 } 4077 4078 return nil 4079} 4080 4081func awsAwsquery_serializeDocumentBouncedRecipientInfoList(v []types.BouncedRecipientInfo, value query.Value) error { 4082 if len(v) == 0 { 4083 return nil 4084 } 4085 array := value.Array("member") 4086 4087 for i := range v { 4088 av := array.Value() 4089 if err := awsAwsquery_serializeDocumentBouncedRecipientInfo(&v[i], av); err != nil { 4090 return err 4091 } 4092 } 4093 return nil 4094} 4095 4096func awsAwsquery_serializeDocumentBulkEmailDestination(v *types.BulkEmailDestination, value query.Value) error { 4097 object := value.Object() 4098 _ = object 4099 4100 if v.Destination != nil { 4101 objectKey := object.Key("Destination") 4102 if err := awsAwsquery_serializeDocumentDestination(v.Destination, objectKey); err != nil { 4103 return err 4104 } 4105 } 4106 4107 if v.ReplacementTags != nil { 4108 objectKey := object.Key("ReplacementTags") 4109 if err := awsAwsquery_serializeDocumentMessageTagList(v.ReplacementTags, objectKey); err != nil { 4110 return err 4111 } 4112 } 4113 4114 if v.ReplacementTemplateData != nil { 4115 objectKey := object.Key("ReplacementTemplateData") 4116 objectKey.String(*v.ReplacementTemplateData) 4117 } 4118 4119 return nil 4120} 4121 4122func awsAwsquery_serializeDocumentBulkEmailDestinationList(v []types.BulkEmailDestination, value query.Value) error { 4123 if len(v) == 0 { 4124 return nil 4125 } 4126 array := value.Array("member") 4127 4128 for i := range v { 4129 av := array.Value() 4130 if err := awsAwsquery_serializeDocumentBulkEmailDestination(&v[i], av); err != nil { 4131 return err 4132 } 4133 } 4134 return nil 4135} 4136 4137func awsAwsquery_serializeDocumentCloudWatchDestination(v *types.CloudWatchDestination, value query.Value) error { 4138 object := value.Object() 4139 _ = object 4140 4141 if v.DimensionConfigurations != nil { 4142 objectKey := object.Key("DimensionConfigurations") 4143 if err := awsAwsquery_serializeDocumentCloudWatchDimensionConfigurations(v.DimensionConfigurations, objectKey); err != nil { 4144 return err 4145 } 4146 } 4147 4148 return nil 4149} 4150 4151func awsAwsquery_serializeDocumentCloudWatchDimensionConfiguration(v *types.CloudWatchDimensionConfiguration, value query.Value) error { 4152 object := value.Object() 4153 _ = object 4154 4155 if v.DefaultDimensionValue != nil { 4156 objectKey := object.Key("DefaultDimensionValue") 4157 objectKey.String(*v.DefaultDimensionValue) 4158 } 4159 4160 if v.DimensionName != nil { 4161 objectKey := object.Key("DimensionName") 4162 objectKey.String(*v.DimensionName) 4163 } 4164 4165 if len(v.DimensionValueSource) > 0 { 4166 objectKey := object.Key("DimensionValueSource") 4167 objectKey.String(string(v.DimensionValueSource)) 4168 } 4169 4170 return nil 4171} 4172 4173func awsAwsquery_serializeDocumentCloudWatchDimensionConfigurations(v []types.CloudWatchDimensionConfiguration, value query.Value) error { 4174 if len(v) == 0 { 4175 return nil 4176 } 4177 array := value.Array("member") 4178 4179 for i := range v { 4180 av := array.Value() 4181 if err := awsAwsquery_serializeDocumentCloudWatchDimensionConfiguration(&v[i], av); err != nil { 4182 return err 4183 } 4184 } 4185 return nil 4186} 4187 4188func awsAwsquery_serializeDocumentConfigurationSet(v *types.ConfigurationSet, value query.Value) error { 4189 object := value.Object() 4190 _ = object 4191 4192 if v.Name != nil { 4193 objectKey := object.Key("Name") 4194 objectKey.String(*v.Name) 4195 } 4196 4197 return nil 4198} 4199 4200func awsAwsquery_serializeDocumentConfigurationSetAttributeList(v []types.ConfigurationSetAttribute, value query.Value) error { 4201 if len(v) == 0 { 4202 return nil 4203 } 4204 array := value.Array("member") 4205 4206 for i := range v { 4207 av := array.Value() 4208 av.String(string(v[i])) 4209 } 4210 return nil 4211} 4212 4213func awsAwsquery_serializeDocumentContent(v *types.Content, value query.Value) error { 4214 object := value.Object() 4215 _ = object 4216 4217 if v.Charset != nil { 4218 objectKey := object.Key("Charset") 4219 objectKey.String(*v.Charset) 4220 } 4221 4222 if v.Data != nil { 4223 objectKey := object.Key("Data") 4224 objectKey.String(*v.Data) 4225 } 4226 4227 return nil 4228} 4229 4230func awsAwsquery_serializeDocumentDeliveryOptions(v *types.DeliveryOptions, value query.Value) error { 4231 object := value.Object() 4232 _ = object 4233 4234 if len(v.TlsPolicy) > 0 { 4235 objectKey := object.Key("TlsPolicy") 4236 objectKey.String(string(v.TlsPolicy)) 4237 } 4238 4239 return nil 4240} 4241 4242func awsAwsquery_serializeDocumentDestination(v *types.Destination, value query.Value) error { 4243 object := value.Object() 4244 _ = object 4245 4246 if v.BccAddresses != nil { 4247 objectKey := object.Key("BccAddresses") 4248 if err := awsAwsquery_serializeDocumentAddressList(v.BccAddresses, objectKey); err != nil { 4249 return err 4250 } 4251 } 4252 4253 if v.CcAddresses != nil { 4254 objectKey := object.Key("CcAddresses") 4255 if err := awsAwsquery_serializeDocumentAddressList(v.CcAddresses, objectKey); err != nil { 4256 return err 4257 } 4258 } 4259 4260 if v.ToAddresses != nil { 4261 objectKey := object.Key("ToAddresses") 4262 if err := awsAwsquery_serializeDocumentAddressList(v.ToAddresses, objectKey); err != nil { 4263 return err 4264 } 4265 } 4266 4267 return nil 4268} 4269 4270func awsAwsquery_serializeDocumentEventDestination(v *types.EventDestination, value query.Value) error { 4271 object := value.Object() 4272 _ = object 4273 4274 if v.CloudWatchDestination != nil { 4275 objectKey := object.Key("CloudWatchDestination") 4276 if err := awsAwsquery_serializeDocumentCloudWatchDestination(v.CloudWatchDestination, objectKey); err != nil { 4277 return err 4278 } 4279 } 4280 4281 if v.Enabled { 4282 objectKey := object.Key("Enabled") 4283 objectKey.Boolean(v.Enabled) 4284 } 4285 4286 if v.KinesisFirehoseDestination != nil { 4287 objectKey := object.Key("KinesisFirehoseDestination") 4288 if err := awsAwsquery_serializeDocumentKinesisFirehoseDestination(v.KinesisFirehoseDestination, objectKey); err != nil { 4289 return err 4290 } 4291 } 4292 4293 if v.MatchingEventTypes != nil { 4294 objectKey := object.Key("MatchingEventTypes") 4295 if err := awsAwsquery_serializeDocumentEventTypes(v.MatchingEventTypes, objectKey); err != nil { 4296 return err 4297 } 4298 } 4299 4300 if v.Name != nil { 4301 objectKey := object.Key("Name") 4302 objectKey.String(*v.Name) 4303 } 4304 4305 if v.SNSDestination != nil { 4306 objectKey := object.Key("SNSDestination") 4307 if err := awsAwsquery_serializeDocumentSNSDestination(v.SNSDestination, objectKey); err != nil { 4308 return err 4309 } 4310 } 4311 4312 return nil 4313} 4314 4315func awsAwsquery_serializeDocumentEventTypes(v []types.EventType, value query.Value) error { 4316 if len(v) == 0 { 4317 return nil 4318 } 4319 array := value.Array("member") 4320 4321 for i := range v { 4322 av := array.Value() 4323 av.String(string(v[i])) 4324 } 4325 return nil 4326} 4327 4328func awsAwsquery_serializeDocumentExtensionField(v *types.ExtensionField, value query.Value) error { 4329 object := value.Object() 4330 _ = object 4331 4332 if v.Name != nil { 4333 objectKey := object.Key("Name") 4334 objectKey.String(*v.Name) 4335 } 4336 4337 if v.Value != nil { 4338 objectKey := object.Key("Value") 4339 objectKey.String(*v.Value) 4340 } 4341 4342 return nil 4343} 4344 4345func awsAwsquery_serializeDocumentExtensionFieldList(v []types.ExtensionField, value query.Value) error { 4346 if len(v) == 0 { 4347 return nil 4348 } 4349 array := value.Array("member") 4350 4351 for i := range v { 4352 av := array.Value() 4353 if err := awsAwsquery_serializeDocumentExtensionField(&v[i], av); err != nil { 4354 return err 4355 } 4356 } 4357 return nil 4358} 4359 4360func awsAwsquery_serializeDocumentIdentityList(v []string, value query.Value) error { 4361 if len(v) == 0 { 4362 return nil 4363 } 4364 array := value.Array("member") 4365 4366 for i := range v { 4367 av := array.Value() 4368 av.String(v[i]) 4369 } 4370 return nil 4371} 4372 4373func awsAwsquery_serializeDocumentKinesisFirehoseDestination(v *types.KinesisFirehoseDestination, value query.Value) error { 4374 object := value.Object() 4375 _ = object 4376 4377 if v.DeliveryStreamARN != nil { 4378 objectKey := object.Key("DeliveryStreamARN") 4379 objectKey.String(*v.DeliveryStreamARN) 4380 } 4381 4382 if v.IAMRoleARN != nil { 4383 objectKey := object.Key("IAMRoleARN") 4384 objectKey.String(*v.IAMRoleARN) 4385 } 4386 4387 return nil 4388} 4389 4390func awsAwsquery_serializeDocumentLambdaAction(v *types.LambdaAction, value query.Value) error { 4391 object := value.Object() 4392 _ = object 4393 4394 if v.FunctionArn != nil { 4395 objectKey := object.Key("FunctionArn") 4396 objectKey.String(*v.FunctionArn) 4397 } 4398 4399 if len(v.InvocationType) > 0 { 4400 objectKey := object.Key("InvocationType") 4401 objectKey.String(string(v.InvocationType)) 4402 } 4403 4404 if v.TopicArn != nil { 4405 objectKey := object.Key("TopicArn") 4406 objectKey.String(*v.TopicArn) 4407 } 4408 4409 return nil 4410} 4411 4412func awsAwsquery_serializeDocumentMessage(v *types.Message, value query.Value) error { 4413 object := value.Object() 4414 _ = object 4415 4416 if v.Body != nil { 4417 objectKey := object.Key("Body") 4418 if err := awsAwsquery_serializeDocumentBody(v.Body, objectKey); err != nil { 4419 return err 4420 } 4421 } 4422 4423 if v.Subject != nil { 4424 objectKey := object.Key("Subject") 4425 if err := awsAwsquery_serializeDocumentContent(v.Subject, objectKey); err != nil { 4426 return err 4427 } 4428 } 4429 4430 return nil 4431} 4432 4433func awsAwsquery_serializeDocumentMessageDsn(v *types.MessageDsn, value query.Value) error { 4434 object := value.Object() 4435 _ = object 4436 4437 if v.ArrivalDate != nil { 4438 objectKey := object.Key("ArrivalDate") 4439 objectKey.String(smithytime.FormatDateTime(*v.ArrivalDate)) 4440 } 4441 4442 if v.ExtensionFields != nil { 4443 objectKey := object.Key("ExtensionFields") 4444 if err := awsAwsquery_serializeDocumentExtensionFieldList(v.ExtensionFields, objectKey); err != nil { 4445 return err 4446 } 4447 } 4448 4449 if v.ReportingMta != nil { 4450 objectKey := object.Key("ReportingMta") 4451 objectKey.String(*v.ReportingMta) 4452 } 4453 4454 return nil 4455} 4456 4457func awsAwsquery_serializeDocumentMessageTag(v *types.MessageTag, value query.Value) error { 4458 object := value.Object() 4459 _ = object 4460 4461 if v.Name != nil { 4462 objectKey := object.Key("Name") 4463 objectKey.String(*v.Name) 4464 } 4465 4466 if v.Value != nil { 4467 objectKey := object.Key("Value") 4468 objectKey.String(*v.Value) 4469 } 4470 4471 return nil 4472} 4473 4474func awsAwsquery_serializeDocumentMessageTagList(v []types.MessageTag, value query.Value) error { 4475 if len(v) == 0 { 4476 return nil 4477 } 4478 array := value.Array("member") 4479 4480 for i := range v { 4481 av := array.Value() 4482 if err := awsAwsquery_serializeDocumentMessageTag(&v[i], av); err != nil { 4483 return err 4484 } 4485 } 4486 return nil 4487} 4488 4489func awsAwsquery_serializeDocumentPolicyNameList(v []string, value query.Value) error { 4490 if len(v) == 0 { 4491 return nil 4492 } 4493 array := value.Array("member") 4494 4495 for i := range v { 4496 av := array.Value() 4497 av.String(v[i]) 4498 } 4499 return nil 4500} 4501 4502func awsAwsquery_serializeDocumentRawMessage(v *types.RawMessage, value query.Value) error { 4503 object := value.Object() 4504 _ = object 4505 4506 if v.Data != nil { 4507 objectKey := object.Key("Data") 4508 objectKey.Base64EncodeBytes(v.Data) 4509 } 4510 4511 return nil 4512} 4513 4514func awsAwsquery_serializeDocumentReceiptAction(v *types.ReceiptAction, value query.Value) error { 4515 object := value.Object() 4516 _ = object 4517 4518 if v.AddHeaderAction != nil { 4519 objectKey := object.Key("AddHeaderAction") 4520 if err := awsAwsquery_serializeDocumentAddHeaderAction(v.AddHeaderAction, objectKey); err != nil { 4521 return err 4522 } 4523 } 4524 4525 if v.BounceAction != nil { 4526 objectKey := object.Key("BounceAction") 4527 if err := awsAwsquery_serializeDocumentBounceAction(v.BounceAction, objectKey); err != nil { 4528 return err 4529 } 4530 } 4531 4532 if v.LambdaAction != nil { 4533 objectKey := object.Key("LambdaAction") 4534 if err := awsAwsquery_serializeDocumentLambdaAction(v.LambdaAction, objectKey); err != nil { 4535 return err 4536 } 4537 } 4538 4539 if v.S3Action != nil { 4540 objectKey := object.Key("S3Action") 4541 if err := awsAwsquery_serializeDocumentS3Action(v.S3Action, objectKey); err != nil { 4542 return err 4543 } 4544 } 4545 4546 if v.SNSAction != nil { 4547 objectKey := object.Key("SNSAction") 4548 if err := awsAwsquery_serializeDocumentSNSAction(v.SNSAction, objectKey); err != nil { 4549 return err 4550 } 4551 } 4552 4553 if v.StopAction != nil { 4554 objectKey := object.Key("StopAction") 4555 if err := awsAwsquery_serializeDocumentStopAction(v.StopAction, objectKey); err != nil { 4556 return err 4557 } 4558 } 4559 4560 if v.WorkmailAction != nil { 4561 objectKey := object.Key("WorkmailAction") 4562 if err := awsAwsquery_serializeDocumentWorkmailAction(v.WorkmailAction, objectKey); err != nil { 4563 return err 4564 } 4565 } 4566 4567 return nil 4568} 4569 4570func awsAwsquery_serializeDocumentReceiptActionsList(v []types.ReceiptAction, value query.Value) error { 4571 if len(v) == 0 { 4572 return nil 4573 } 4574 array := value.Array("member") 4575 4576 for i := range v { 4577 av := array.Value() 4578 if err := awsAwsquery_serializeDocumentReceiptAction(&v[i], av); err != nil { 4579 return err 4580 } 4581 } 4582 return nil 4583} 4584 4585func awsAwsquery_serializeDocumentReceiptFilter(v *types.ReceiptFilter, value query.Value) error { 4586 object := value.Object() 4587 _ = object 4588 4589 if v.IpFilter != nil { 4590 objectKey := object.Key("IpFilter") 4591 if err := awsAwsquery_serializeDocumentReceiptIpFilter(v.IpFilter, objectKey); err != nil { 4592 return err 4593 } 4594 } 4595 4596 if v.Name != nil { 4597 objectKey := object.Key("Name") 4598 objectKey.String(*v.Name) 4599 } 4600 4601 return nil 4602} 4603 4604func awsAwsquery_serializeDocumentReceiptIpFilter(v *types.ReceiptIpFilter, value query.Value) error { 4605 object := value.Object() 4606 _ = object 4607 4608 if v.Cidr != nil { 4609 objectKey := object.Key("Cidr") 4610 objectKey.String(*v.Cidr) 4611 } 4612 4613 if len(v.Policy) > 0 { 4614 objectKey := object.Key("Policy") 4615 objectKey.String(string(v.Policy)) 4616 } 4617 4618 return nil 4619} 4620 4621func awsAwsquery_serializeDocumentReceiptRule(v *types.ReceiptRule, value query.Value) error { 4622 object := value.Object() 4623 _ = object 4624 4625 if v.Actions != nil { 4626 objectKey := object.Key("Actions") 4627 if err := awsAwsquery_serializeDocumentReceiptActionsList(v.Actions, objectKey); err != nil { 4628 return err 4629 } 4630 } 4631 4632 if v.Enabled { 4633 objectKey := object.Key("Enabled") 4634 objectKey.Boolean(v.Enabled) 4635 } 4636 4637 if v.Name != nil { 4638 objectKey := object.Key("Name") 4639 objectKey.String(*v.Name) 4640 } 4641 4642 if v.Recipients != nil { 4643 objectKey := object.Key("Recipients") 4644 if err := awsAwsquery_serializeDocumentRecipientsList(v.Recipients, objectKey); err != nil { 4645 return err 4646 } 4647 } 4648 4649 if v.ScanEnabled { 4650 objectKey := object.Key("ScanEnabled") 4651 objectKey.Boolean(v.ScanEnabled) 4652 } 4653 4654 if len(v.TlsPolicy) > 0 { 4655 objectKey := object.Key("TlsPolicy") 4656 objectKey.String(string(v.TlsPolicy)) 4657 } 4658 4659 return nil 4660} 4661 4662func awsAwsquery_serializeDocumentReceiptRuleNamesList(v []string, value query.Value) error { 4663 if len(v) == 0 { 4664 return nil 4665 } 4666 array := value.Array("member") 4667 4668 for i := range v { 4669 av := array.Value() 4670 av.String(v[i]) 4671 } 4672 return nil 4673} 4674 4675func awsAwsquery_serializeDocumentRecipientDsnFields(v *types.RecipientDsnFields, value query.Value) error { 4676 object := value.Object() 4677 _ = object 4678 4679 if len(v.Action) > 0 { 4680 objectKey := object.Key("Action") 4681 objectKey.String(string(v.Action)) 4682 } 4683 4684 if v.DiagnosticCode != nil { 4685 objectKey := object.Key("DiagnosticCode") 4686 objectKey.String(*v.DiagnosticCode) 4687 } 4688 4689 if v.ExtensionFields != nil { 4690 objectKey := object.Key("ExtensionFields") 4691 if err := awsAwsquery_serializeDocumentExtensionFieldList(v.ExtensionFields, objectKey); err != nil { 4692 return err 4693 } 4694 } 4695 4696 if v.FinalRecipient != nil { 4697 objectKey := object.Key("FinalRecipient") 4698 objectKey.String(*v.FinalRecipient) 4699 } 4700 4701 if v.LastAttemptDate != nil { 4702 objectKey := object.Key("LastAttemptDate") 4703 objectKey.String(smithytime.FormatDateTime(*v.LastAttemptDate)) 4704 } 4705 4706 if v.RemoteMta != nil { 4707 objectKey := object.Key("RemoteMta") 4708 objectKey.String(*v.RemoteMta) 4709 } 4710 4711 if v.Status != nil { 4712 objectKey := object.Key("Status") 4713 objectKey.String(*v.Status) 4714 } 4715 4716 return nil 4717} 4718 4719func awsAwsquery_serializeDocumentRecipientsList(v []string, value query.Value) error { 4720 if len(v) == 0 { 4721 return nil 4722 } 4723 array := value.Array("member") 4724 4725 for i := range v { 4726 av := array.Value() 4727 av.String(v[i]) 4728 } 4729 return nil 4730} 4731 4732func awsAwsquery_serializeDocumentS3Action(v *types.S3Action, value query.Value) error { 4733 object := value.Object() 4734 _ = object 4735 4736 if v.BucketName != nil { 4737 objectKey := object.Key("BucketName") 4738 objectKey.String(*v.BucketName) 4739 } 4740 4741 if v.KmsKeyArn != nil { 4742 objectKey := object.Key("KmsKeyArn") 4743 objectKey.String(*v.KmsKeyArn) 4744 } 4745 4746 if v.ObjectKeyPrefix != nil { 4747 objectKey := object.Key("ObjectKeyPrefix") 4748 objectKey.String(*v.ObjectKeyPrefix) 4749 } 4750 4751 if v.TopicArn != nil { 4752 objectKey := object.Key("TopicArn") 4753 objectKey.String(*v.TopicArn) 4754 } 4755 4756 return nil 4757} 4758 4759func awsAwsquery_serializeDocumentSNSAction(v *types.SNSAction, value query.Value) error { 4760 object := value.Object() 4761 _ = object 4762 4763 if len(v.Encoding) > 0 { 4764 objectKey := object.Key("Encoding") 4765 objectKey.String(string(v.Encoding)) 4766 } 4767 4768 if v.TopicArn != nil { 4769 objectKey := object.Key("TopicArn") 4770 objectKey.String(*v.TopicArn) 4771 } 4772 4773 return nil 4774} 4775 4776func awsAwsquery_serializeDocumentSNSDestination(v *types.SNSDestination, value query.Value) error { 4777 object := value.Object() 4778 _ = object 4779 4780 if v.TopicARN != nil { 4781 objectKey := object.Key("TopicARN") 4782 objectKey.String(*v.TopicARN) 4783 } 4784 4785 return nil 4786} 4787 4788func awsAwsquery_serializeDocumentStopAction(v *types.StopAction, value query.Value) error { 4789 object := value.Object() 4790 _ = object 4791 4792 if len(v.Scope) > 0 { 4793 objectKey := object.Key("Scope") 4794 objectKey.String(string(v.Scope)) 4795 } 4796 4797 if v.TopicArn != nil { 4798 objectKey := object.Key("TopicArn") 4799 objectKey.String(*v.TopicArn) 4800 } 4801 4802 return nil 4803} 4804 4805func awsAwsquery_serializeDocumentTemplate(v *types.Template, value query.Value) error { 4806 object := value.Object() 4807 _ = object 4808 4809 if v.HtmlPart != nil { 4810 objectKey := object.Key("HtmlPart") 4811 objectKey.String(*v.HtmlPart) 4812 } 4813 4814 if v.SubjectPart != nil { 4815 objectKey := object.Key("SubjectPart") 4816 objectKey.String(*v.SubjectPart) 4817 } 4818 4819 if v.TemplateName != nil { 4820 objectKey := object.Key("TemplateName") 4821 objectKey.String(*v.TemplateName) 4822 } 4823 4824 if v.TextPart != nil { 4825 objectKey := object.Key("TextPart") 4826 objectKey.String(*v.TextPart) 4827 } 4828 4829 return nil 4830} 4831 4832func awsAwsquery_serializeDocumentTrackingOptions(v *types.TrackingOptions, value query.Value) error { 4833 object := value.Object() 4834 _ = object 4835 4836 if v.CustomRedirectDomain != nil { 4837 objectKey := object.Key("CustomRedirectDomain") 4838 objectKey.String(*v.CustomRedirectDomain) 4839 } 4840 4841 return nil 4842} 4843 4844func awsAwsquery_serializeDocumentWorkmailAction(v *types.WorkmailAction, value query.Value) error { 4845 object := value.Object() 4846 _ = object 4847 4848 if v.OrganizationArn != nil { 4849 objectKey := object.Key("OrganizationArn") 4850 objectKey.String(*v.OrganizationArn) 4851 } 4852 4853 if v.TopicArn != nil { 4854 objectKey := object.Key("TopicArn") 4855 objectKey.String(*v.TopicArn) 4856 } 4857 4858 return nil 4859} 4860 4861func awsAwsquery_serializeOpDocumentCloneReceiptRuleSetInput(v *CloneReceiptRuleSetInput, value query.Value) error { 4862 object := value.Object() 4863 _ = object 4864 4865 if v.OriginalRuleSetName != nil { 4866 objectKey := object.Key("OriginalRuleSetName") 4867 objectKey.String(*v.OriginalRuleSetName) 4868 } 4869 4870 if v.RuleSetName != nil { 4871 objectKey := object.Key("RuleSetName") 4872 objectKey.String(*v.RuleSetName) 4873 } 4874 4875 return nil 4876} 4877 4878func awsAwsquery_serializeOpDocumentCreateConfigurationSetEventDestinationInput(v *CreateConfigurationSetEventDestinationInput, value query.Value) error { 4879 object := value.Object() 4880 _ = object 4881 4882 if v.ConfigurationSetName != nil { 4883 objectKey := object.Key("ConfigurationSetName") 4884 objectKey.String(*v.ConfigurationSetName) 4885 } 4886 4887 if v.EventDestination != nil { 4888 objectKey := object.Key("EventDestination") 4889 if err := awsAwsquery_serializeDocumentEventDestination(v.EventDestination, objectKey); err != nil { 4890 return err 4891 } 4892 } 4893 4894 return nil 4895} 4896 4897func awsAwsquery_serializeOpDocumentCreateConfigurationSetInput(v *CreateConfigurationSetInput, value query.Value) error { 4898 object := value.Object() 4899 _ = object 4900 4901 if v.ConfigurationSet != nil { 4902 objectKey := object.Key("ConfigurationSet") 4903 if err := awsAwsquery_serializeDocumentConfigurationSet(v.ConfigurationSet, objectKey); err != nil { 4904 return err 4905 } 4906 } 4907 4908 return nil 4909} 4910 4911func awsAwsquery_serializeOpDocumentCreateConfigurationSetTrackingOptionsInput(v *CreateConfigurationSetTrackingOptionsInput, value query.Value) error { 4912 object := value.Object() 4913 _ = object 4914 4915 if v.ConfigurationSetName != nil { 4916 objectKey := object.Key("ConfigurationSetName") 4917 objectKey.String(*v.ConfigurationSetName) 4918 } 4919 4920 if v.TrackingOptions != nil { 4921 objectKey := object.Key("TrackingOptions") 4922 if err := awsAwsquery_serializeDocumentTrackingOptions(v.TrackingOptions, objectKey); err != nil { 4923 return err 4924 } 4925 } 4926 4927 return nil 4928} 4929 4930func awsAwsquery_serializeOpDocumentCreateCustomVerificationEmailTemplateInput(v *CreateCustomVerificationEmailTemplateInput, value query.Value) error { 4931 object := value.Object() 4932 _ = object 4933 4934 if v.FailureRedirectionURL != nil { 4935 objectKey := object.Key("FailureRedirectionURL") 4936 objectKey.String(*v.FailureRedirectionURL) 4937 } 4938 4939 if v.FromEmailAddress != nil { 4940 objectKey := object.Key("FromEmailAddress") 4941 objectKey.String(*v.FromEmailAddress) 4942 } 4943 4944 if v.SuccessRedirectionURL != nil { 4945 objectKey := object.Key("SuccessRedirectionURL") 4946 objectKey.String(*v.SuccessRedirectionURL) 4947 } 4948 4949 if v.TemplateContent != nil { 4950 objectKey := object.Key("TemplateContent") 4951 objectKey.String(*v.TemplateContent) 4952 } 4953 4954 if v.TemplateName != nil { 4955 objectKey := object.Key("TemplateName") 4956 objectKey.String(*v.TemplateName) 4957 } 4958 4959 if v.TemplateSubject != nil { 4960 objectKey := object.Key("TemplateSubject") 4961 objectKey.String(*v.TemplateSubject) 4962 } 4963 4964 return nil 4965} 4966 4967func awsAwsquery_serializeOpDocumentCreateReceiptFilterInput(v *CreateReceiptFilterInput, value query.Value) error { 4968 object := value.Object() 4969 _ = object 4970 4971 if v.Filter != nil { 4972 objectKey := object.Key("Filter") 4973 if err := awsAwsquery_serializeDocumentReceiptFilter(v.Filter, objectKey); err != nil { 4974 return err 4975 } 4976 } 4977 4978 return nil 4979} 4980 4981func awsAwsquery_serializeOpDocumentCreateReceiptRuleInput(v *CreateReceiptRuleInput, value query.Value) error { 4982 object := value.Object() 4983 _ = object 4984 4985 if v.After != nil { 4986 objectKey := object.Key("After") 4987 objectKey.String(*v.After) 4988 } 4989 4990 if v.Rule != nil { 4991 objectKey := object.Key("Rule") 4992 if err := awsAwsquery_serializeDocumentReceiptRule(v.Rule, objectKey); err != nil { 4993 return err 4994 } 4995 } 4996 4997 if v.RuleSetName != nil { 4998 objectKey := object.Key("RuleSetName") 4999 objectKey.String(*v.RuleSetName) 5000 } 5001 5002 return nil 5003} 5004 5005func awsAwsquery_serializeOpDocumentCreateReceiptRuleSetInput(v *CreateReceiptRuleSetInput, value query.Value) error { 5006 object := value.Object() 5007 _ = object 5008 5009 if v.RuleSetName != nil { 5010 objectKey := object.Key("RuleSetName") 5011 objectKey.String(*v.RuleSetName) 5012 } 5013 5014 return nil 5015} 5016 5017func awsAwsquery_serializeOpDocumentCreateTemplateInput(v *CreateTemplateInput, value query.Value) error { 5018 object := value.Object() 5019 _ = object 5020 5021 if v.Template != nil { 5022 objectKey := object.Key("Template") 5023 if err := awsAwsquery_serializeDocumentTemplate(v.Template, objectKey); err != nil { 5024 return err 5025 } 5026 } 5027 5028 return nil 5029} 5030 5031func awsAwsquery_serializeOpDocumentDeleteConfigurationSetEventDestinationInput(v *DeleteConfigurationSetEventDestinationInput, value query.Value) error { 5032 object := value.Object() 5033 _ = object 5034 5035 if v.ConfigurationSetName != nil { 5036 objectKey := object.Key("ConfigurationSetName") 5037 objectKey.String(*v.ConfigurationSetName) 5038 } 5039 5040 if v.EventDestinationName != nil { 5041 objectKey := object.Key("EventDestinationName") 5042 objectKey.String(*v.EventDestinationName) 5043 } 5044 5045 return nil 5046} 5047 5048func awsAwsquery_serializeOpDocumentDeleteConfigurationSetInput(v *DeleteConfigurationSetInput, value query.Value) error { 5049 object := value.Object() 5050 _ = object 5051 5052 if v.ConfigurationSetName != nil { 5053 objectKey := object.Key("ConfigurationSetName") 5054 objectKey.String(*v.ConfigurationSetName) 5055 } 5056 5057 return nil 5058} 5059 5060func awsAwsquery_serializeOpDocumentDeleteConfigurationSetTrackingOptionsInput(v *DeleteConfigurationSetTrackingOptionsInput, value query.Value) error { 5061 object := value.Object() 5062 _ = object 5063 5064 if v.ConfigurationSetName != nil { 5065 objectKey := object.Key("ConfigurationSetName") 5066 objectKey.String(*v.ConfigurationSetName) 5067 } 5068 5069 return nil 5070} 5071 5072func awsAwsquery_serializeOpDocumentDeleteCustomVerificationEmailTemplateInput(v *DeleteCustomVerificationEmailTemplateInput, value query.Value) error { 5073 object := value.Object() 5074 _ = object 5075 5076 if v.TemplateName != nil { 5077 objectKey := object.Key("TemplateName") 5078 objectKey.String(*v.TemplateName) 5079 } 5080 5081 return nil 5082} 5083 5084func awsAwsquery_serializeOpDocumentDeleteIdentityInput(v *DeleteIdentityInput, value query.Value) error { 5085 object := value.Object() 5086 _ = object 5087 5088 if v.Identity != nil { 5089 objectKey := object.Key("Identity") 5090 objectKey.String(*v.Identity) 5091 } 5092 5093 return nil 5094} 5095 5096func awsAwsquery_serializeOpDocumentDeleteIdentityPolicyInput(v *DeleteIdentityPolicyInput, value query.Value) error { 5097 object := value.Object() 5098 _ = object 5099 5100 if v.Identity != nil { 5101 objectKey := object.Key("Identity") 5102 objectKey.String(*v.Identity) 5103 } 5104 5105 if v.PolicyName != nil { 5106 objectKey := object.Key("PolicyName") 5107 objectKey.String(*v.PolicyName) 5108 } 5109 5110 return nil 5111} 5112 5113func awsAwsquery_serializeOpDocumentDeleteReceiptFilterInput(v *DeleteReceiptFilterInput, value query.Value) error { 5114 object := value.Object() 5115 _ = object 5116 5117 if v.FilterName != nil { 5118 objectKey := object.Key("FilterName") 5119 objectKey.String(*v.FilterName) 5120 } 5121 5122 return nil 5123} 5124 5125func awsAwsquery_serializeOpDocumentDeleteReceiptRuleInput(v *DeleteReceiptRuleInput, value query.Value) error { 5126 object := value.Object() 5127 _ = object 5128 5129 if v.RuleName != nil { 5130 objectKey := object.Key("RuleName") 5131 objectKey.String(*v.RuleName) 5132 } 5133 5134 if v.RuleSetName != nil { 5135 objectKey := object.Key("RuleSetName") 5136 objectKey.String(*v.RuleSetName) 5137 } 5138 5139 return nil 5140} 5141 5142func awsAwsquery_serializeOpDocumentDeleteReceiptRuleSetInput(v *DeleteReceiptRuleSetInput, value query.Value) error { 5143 object := value.Object() 5144 _ = object 5145 5146 if v.RuleSetName != nil { 5147 objectKey := object.Key("RuleSetName") 5148 objectKey.String(*v.RuleSetName) 5149 } 5150 5151 return nil 5152} 5153 5154func awsAwsquery_serializeOpDocumentDeleteTemplateInput(v *DeleteTemplateInput, value query.Value) error { 5155 object := value.Object() 5156 _ = object 5157 5158 if v.TemplateName != nil { 5159 objectKey := object.Key("TemplateName") 5160 objectKey.String(*v.TemplateName) 5161 } 5162 5163 return nil 5164} 5165 5166func awsAwsquery_serializeOpDocumentDeleteVerifiedEmailAddressInput(v *DeleteVerifiedEmailAddressInput, value query.Value) error { 5167 object := value.Object() 5168 _ = object 5169 5170 if v.EmailAddress != nil { 5171 objectKey := object.Key("EmailAddress") 5172 objectKey.String(*v.EmailAddress) 5173 } 5174 5175 return nil 5176} 5177 5178func awsAwsquery_serializeOpDocumentDescribeActiveReceiptRuleSetInput(v *DescribeActiveReceiptRuleSetInput, value query.Value) error { 5179 object := value.Object() 5180 _ = object 5181 5182 return nil 5183} 5184 5185func awsAwsquery_serializeOpDocumentDescribeConfigurationSetInput(v *DescribeConfigurationSetInput, value query.Value) error { 5186 object := value.Object() 5187 _ = object 5188 5189 if v.ConfigurationSetAttributeNames != nil { 5190 objectKey := object.Key("ConfigurationSetAttributeNames") 5191 if err := awsAwsquery_serializeDocumentConfigurationSetAttributeList(v.ConfigurationSetAttributeNames, objectKey); err != nil { 5192 return err 5193 } 5194 } 5195 5196 if v.ConfigurationSetName != nil { 5197 objectKey := object.Key("ConfigurationSetName") 5198 objectKey.String(*v.ConfigurationSetName) 5199 } 5200 5201 return nil 5202} 5203 5204func awsAwsquery_serializeOpDocumentDescribeReceiptRuleInput(v *DescribeReceiptRuleInput, value query.Value) error { 5205 object := value.Object() 5206 _ = object 5207 5208 if v.RuleName != nil { 5209 objectKey := object.Key("RuleName") 5210 objectKey.String(*v.RuleName) 5211 } 5212 5213 if v.RuleSetName != nil { 5214 objectKey := object.Key("RuleSetName") 5215 objectKey.String(*v.RuleSetName) 5216 } 5217 5218 return nil 5219} 5220 5221func awsAwsquery_serializeOpDocumentDescribeReceiptRuleSetInput(v *DescribeReceiptRuleSetInput, value query.Value) error { 5222 object := value.Object() 5223 _ = object 5224 5225 if v.RuleSetName != nil { 5226 objectKey := object.Key("RuleSetName") 5227 objectKey.String(*v.RuleSetName) 5228 } 5229 5230 return nil 5231} 5232 5233func awsAwsquery_serializeOpDocumentGetCustomVerificationEmailTemplateInput(v *GetCustomVerificationEmailTemplateInput, value query.Value) error { 5234 object := value.Object() 5235 _ = object 5236 5237 if v.TemplateName != nil { 5238 objectKey := object.Key("TemplateName") 5239 objectKey.String(*v.TemplateName) 5240 } 5241 5242 return nil 5243} 5244 5245func awsAwsquery_serializeOpDocumentGetIdentityDkimAttributesInput(v *GetIdentityDkimAttributesInput, value query.Value) error { 5246 object := value.Object() 5247 _ = object 5248 5249 if v.Identities != nil { 5250 objectKey := object.Key("Identities") 5251 if err := awsAwsquery_serializeDocumentIdentityList(v.Identities, objectKey); err != nil { 5252 return err 5253 } 5254 } 5255 5256 return nil 5257} 5258 5259func awsAwsquery_serializeOpDocumentGetIdentityMailFromDomainAttributesInput(v *GetIdentityMailFromDomainAttributesInput, value query.Value) error { 5260 object := value.Object() 5261 _ = object 5262 5263 if v.Identities != nil { 5264 objectKey := object.Key("Identities") 5265 if err := awsAwsquery_serializeDocumentIdentityList(v.Identities, objectKey); err != nil { 5266 return err 5267 } 5268 } 5269 5270 return nil 5271} 5272 5273func awsAwsquery_serializeOpDocumentGetIdentityNotificationAttributesInput(v *GetIdentityNotificationAttributesInput, value query.Value) error { 5274 object := value.Object() 5275 _ = object 5276 5277 if v.Identities != nil { 5278 objectKey := object.Key("Identities") 5279 if err := awsAwsquery_serializeDocumentIdentityList(v.Identities, objectKey); err != nil { 5280 return err 5281 } 5282 } 5283 5284 return nil 5285} 5286 5287func awsAwsquery_serializeOpDocumentGetIdentityPoliciesInput(v *GetIdentityPoliciesInput, value query.Value) error { 5288 object := value.Object() 5289 _ = object 5290 5291 if v.Identity != nil { 5292 objectKey := object.Key("Identity") 5293 objectKey.String(*v.Identity) 5294 } 5295 5296 if v.PolicyNames != nil { 5297 objectKey := object.Key("PolicyNames") 5298 if err := awsAwsquery_serializeDocumentPolicyNameList(v.PolicyNames, objectKey); err != nil { 5299 return err 5300 } 5301 } 5302 5303 return nil 5304} 5305 5306func awsAwsquery_serializeOpDocumentGetIdentityVerificationAttributesInput(v *GetIdentityVerificationAttributesInput, value query.Value) error { 5307 object := value.Object() 5308 _ = object 5309 5310 if v.Identities != nil { 5311 objectKey := object.Key("Identities") 5312 if err := awsAwsquery_serializeDocumentIdentityList(v.Identities, objectKey); err != nil { 5313 return err 5314 } 5315 } 5316 5317 return nil 5318} 5319 5320func awsAwsquery_serializeOpDocumentGetTemplateInput(v *GetTemplateInput, value query.Value) error { 5321 object := value.Object() 5322 _ = object 5323 5324 if v.TemplateName != nil { 5325 objectKey := object.Key("TemplateName") 5326 objectKey.String(*v.TemplateName) 5327 } 5328 5329 return nil 5330} 5331 5332func awsAwsquery_serializeOpDocumentListConfigurationSetsInput(v *ListConfigurationSetsInput, value query.Value) error { 5333 object := value.Object() 5334 _ = object 5335 5336 if v.MaxItems != nil { 5337 objectKey := object.Key("MaxItems") 5338 objectKey.Integer(*v.MaxItems) 5339 } 5340 5341 if v.NextToken != nil { 5342 objectKey := object.Key("NextToken") 5343 objectKey.String(*v.NextToken) 5344 } 5345 5346 return nil 5347} 5348 5349func awsAwsquery_serializeOpDocumentListCustomVerificationEmailTemplatesInput(v *ListCustomVerificationEmailTemplatesInput, value query.Value) error { 5350 object := value.Object() 5351 _ = object 5352 5353 if v.MaxResults != nil { 5354 objectKey := object.Key("MaxResults") 5355 objectKey.Integer(*v.MaxResults) 5356 } 5357 5358 if v.NextToken != nil { 5359 objectKey := object.Key("NextToken") 5360 objectKey.String(*v.NextToken) 5361 } 5362 5363 return nil 5364} 5365 5366func awsAwsquery_serializeOpDocumentListIdentitiesInput(v *ListIdentitiesInput, value query.Value) error { 5367 object := value.Object() 5368 _ = object 5369 5370 if len(v.IdentityType) > 0 { 5371 objectKey := object.Key("IdentityType") 5372 objectKey.String(string(v.IdentityType)) 5373 } 5374 5375 if v.MaxItems != nil { 5376 objectKey := object.Key("MaxItems") 5377 objectKey.Integer(*v.MaxItems) 5378 } 5379 5380 if v.NextToken != nil { 5381 objectKey := object.Key("NextToken") 5382 objectKey.String(*v.NextToken) 5383 } 5384 5385 return nil 5386} 5387 5388func awsAwsquery_serializeOpDocumentListIdentityPoliciesInput(v *ListIdentityPoliciesInput, value query.Value) error { 5389 object := value.Object() 5390 _ = object 5391 5392 if v.Identity != nil { 5393 objectKey := object.Key("Identity") 5394 objectKey.String(*v.Identity) 5395 } 5396 5397 return nil 5398} 5399 5400func awsAwsquery_serializeOpDocumentListReceiptFiltersInput(v *ListReceiptFiltersInput, value query.Value) error { 5401 object := value.Object() 5402 _ = object 5403 5404 return nil 5405} 5406 5407func awsAwsquery_serializeOpDocumentListReceiptRuleSetsInput(v *ListReceiptRuleSetsInput, value query.Value) error { 5408 object := value.Object() 5409 _ = object 5410 5411 if v.NextToken != nil { 5412 objectKey := object.Key("NextToken") 5413 objectKey.String(*v.NextToken) 5414 } 5415 5416 return nil 5417} 5418 5419func awsAwsquery_serializeOpDocumentListTemplatesInput(v *ListTemplatesInput, value query.Value) error { 5420 object := value.Object() 5421 _ = object 5422 5423 if v.MaxItems != nil { 5424 objectKey := object.Key("MaxItems") 5425 objectKey.Integer(*v.MaxItems) 5426 } 5427 5428 if v.NextToken != nil { 5429 objectKey := object.Key("NextToken") 5430 objectKey.String(*v.NextToken) 5431 } 5432 5433 return nil 5434} 5435 5436func awsAwsquery_serializeOpDocumentPutConfigurationSetDeliveryOptionsInput(v *PutConfigurationSetDeliveryOptionsInput, value query.Value) error { 5437 object := value.Object() 5438 _ = object 5439 5440 if v.ConfigurationSetName != nil { 5441 objectKey := object.Key("ConfigurationSetName") 5442 objectKey.String(*v.ConfigurationSetName) 5443 } 5444 5445 if v.DeliveryOptions != nil { 5446 objectKey := object.Key("DeliveryOptions") 5447 if err := awsAwsquery_serializeDocumentDeliveryOptions(v.DeliveryOptions, objectKey); err != nil { 5448 return err 5449 } 5450 } 5451 5452 return nil 5453} 5454 5455func awsAwsquery_serializeOpDocumentPutIdentityPolicyInput(v *PutIdentityPolicyInput, value query.Value) error { 5456 object := value.Object() 5457 _ = object 5458 5459 if v.Identity != nil { 5460 objectKey := object.Key("Identity") 5461 objectKey.String(*v.Identity) 5462 } 5463 5464 if v.Policy != nil { 5465 objectKey := object.Key("Policy") 5466 objectKey.String(*v.Policy) 5467 } 5468 5469 if v.PolicyName != nil { 5470 objectKey := object.Key("PolicyName") 5471 objectKey.String(*v.PolicyName) 5472 } 5473 5474 return nil 5475} 5476 5477func awsAwsquery_serializeOpDocumentReorderReceiptRuleSetInput(v *ReorderReceiptRuleSetInput, value query.Value) error { 5478 object := value.Object() 5479 _ = object 5480 5481 if v.RuleNames != nil { 5482 objectKey := object.Key("RuleNames") 5483 if err := awsAwsquery_serializeDocumentReceiptRuleNamesList(v.RuleNames, objectKey); err != nil { 5484 return err 5485 } 5486 } 5487 5488 if v.RuleSetName != nil { 5489 objectKey := object.Key("RuleSetName") 5490 objectKey.String(*v.RuleSetName) 5491 } 5492 5493 return nil 5494} 5495 5496func awsAwsquery_serializeOpDocumentSendBounceInput(v *SendBounceInput, value query.Value) error { 5497 object := value.Object() 5498 _ = object 5499 5500 if v.BouncedRecipientInfoList != nil { 5501 objectKey := object.Key("BouncedRecipientInfoList") 5502 if err := awsAwsquery_serializeDocumentBouncedRecipientInfoList(v.BouncedRecipientInfoList, objectKey); err != nil { 5503 return err 5504 } 5505 } 5506 5507 if v.BounceSender != nil { 5508 objectKey := object.Key("BounceSender") 5509 objectKey.String(*v.BounceSender) 5510 } 5511 5512 if v.BounceSenderArn != nil { 5513 objectKey := object.Key("BounceSenderArn") 5514 objectKey.String(*v.BounceSenderArn) 5515 } 5516 5517 if v.Explanation != nil { 5518 objectKey := object.Key("Explanation") 5519 objectKey.String(*v.Explanation) 5520 } 5521 5522 if v.MessageDsn != nil { 5523 objectKey := object.Key("MessageDsn") 5524 if err := awsAwsquery_serializeDocumentMessageDsn(v.MessageDsn, objectKey); err != nil { 5525 return err 5526 } 5527 } 5528 5529 if v.OriginalMessageId != nil { 5530 objectKey := object.Key("OriginalMessageId") 5531 objectKey.String(*v.OriginalMessageId) 5532 } 5533 5534 return nil 5535} 5536 5537func awsAwsquery_serializeOpDocumentSendBulkTemplatedEmailInput(v *SendBulkTemplatedEmailInput, value query.Value) error { 5538 object := value.Object() 5539 _ = object 5540 5541 if v.ConfigurationSetName != nil { 5542 objectKey := object.Key("ConfigurationSetName") 5543 objectKey.String(*v.ConfigurationSetName) 5544 } 5545 5546 if v.DefaultTags != nil { 5547 objectKey := object.Key("DefaultTags") 5548 if err := awsAwsquery_serializeDocumentMessageTagList(v.DefaultTags, objectKey); err != nil { 5549 return err 5550 } 5551 } 5552 5553 if v.DefaultTemplateData != nil { 5554 objectKey := object.Key("DefaultTemplateData") 5555 objectKey.String(*v.DefaultTemplateData) 5556 } 5557 5558 if v.Destinations != nil { 5559 objectKey := object.Key("Destinations") 5560 if err := awsAwsquery_serializeDocumentBulkEmailDestinationList(v.Destinations, objectKey); err != nil { 5561 return err 5562 } 5563 } 5564 5565 if v.ReplyToAddresses != nil { 5566 objectKey := object.Key("ReplyToAddresses") 5567 if err := awsAwsquery_serializeDocumentAddressList(v.ReplyToAddresses, objectKey); err != nil { 5568 return err 5569 } 5570 } 5571 5572 if v.ReturnPath != nil { 5573 objectKey := object.Key("ReturnPath") 5574 objectKey.String(*v.ReturnPath) 5575 } 5576 5577 if v.ReturnPathArn != nil { 5578 objectKey := object.Key("ReturnPathArn") 5579 objectKey.String(*v.ReturnPathArn) 5580 } 5581 5582 if v.Source != nil { 5583 objectKey := object.Key("Source") 5584 objectKey.String(*v.Source) 5585 } 5586 5587 if v.SourceArn != nil { 5588 objectKey := object.Key("SourceArn") 5589 objectKey.String(*v.SourceArn) 5590 } 5591 5592 if v.Template != nil { 5593 objectKey := object.Key("Template") 5594 objectKey.String(*v.Template) 5595 } 5596 5597 if v.TemplateArn != nil { 5598 objectKey := object.Key("TemplateArn") 5599 objectKey.String(*v.TemplateArn) 5600 } 5601 5602 return nil 5603} 5604 5605func awsAwsquery_serializeOpDocumentSendCustomVerificationEmailInput(v *SendCustomVerificationEmailInput, value query.Value) error { 5606 object := value.Object() 5607 _ = object 5608 5609 if v.ConfigurationSetName != nil { 5610 objectKey := object.Key("ConfigurationSetName") 5611 objectKey.String(*v.ConfigurationSetName) 5612 } 5613 5614 if v.EmailAddress != nil { 5615 objectKey := object.Key("EmailAddress") 5616 objectKey.String(*v.EmailAddress) 5617 } 5618 5619 if v.TemplateName != nil { 5620 objectKey := object.Key("TemplateName") 5621 objectKey.String(*v.TemplateName) 5622 } 5623 5624 return nil 5625} 5626 5627func awsAwsquery_serializeOpDocumentSendEmailInput(v *SendEmailInput, value query.Value) error { 5628 object := value.Object() 5629 _ = object 5630 5631 if v.ConfigurationSetName != nil { 5632 objectKey := object.Key("ConfigurationSetName") 5633 objectKey.String(*v.ConfigurationSetName) 5634 } 5635 5636 if v.Destination != nil { 5637 objectKey := object.Key("Destination") 5638 if err := awsAwsquery_serializeDocumentDestination(v.Destination, objectKey); err != nil { 5639 return err 5640 } 5641 } 5642 5643 if v.Message != nil { 5644 objectKey := object.Key("Message") 5645 if err := awsAwsquery_serializeDocumentMessage(v.Message, objectKey); err != nil { 5646 return err 5647 } 5648 } 5649 5650 if v.ReplyToAddresses != nil { 5651 objectKey := object.Key("ReplyToAddresses") 5652 if err := awsAwsquery_serializeDocumentAddressList(v.ReplyToAddresses, objectKey); err != nil { 5653 return err 5654 } 5655 } 5656 5657 if v.ReturnPath != nil { 5658 objectKey := object.Key("ReturnPath") 5659 objectKey.String(*v.ReturnPath) 5660 } 5661 5662 if v.ReturnPathArn != nil { 5663 objectKey := object.Key("ReturnPathArn") 5664 objectKey.String(*v.ReturnPathArn) 5665 } 5666 5667 if v.Source != nil { 5668 objectKey := object.Key("Source") 5669 objectKey.String(*v.Source) 5670 } 5671 5672 if v.SourceArn != nil { 5673 objectKey := object.Key("SourceArn") 5674 objectKey.String(*v.SourceArn) 5675 } 5676 5677 if v.Tags != nil { 5678 objectKey := object.Key("Tags") 5679 if err := awsAwsquery_serializeDocumentMessageTagList(v.Tags, objectKey); err != nil { 5680 return err 5681 } 5682 } 5683 5684 return nil 5685} 5686 5687func awsAwsquery_serializeOpDocumentSendRawEmailInput(v *SendRawEmailInput, value query.Value) error { 5688 object := value.Object() 5689 _ = object 5690 5691 if v.ConfigurationSetName != nil { 5692 objectKey := object.Key("ConfigurationSetName") 5693 objectKey.String(*v.ConfigurationSetName) 5694 } 5695 5696 if v.Destinations != nil { 5697 objectKey := object.Key("Destinations") 5698 if err := awsAwsquery_serializeDocumentAddressList(v.Destinations, objectKey); err != nil { 5699 return err 5700 } 5701 } 5702 5703 if v.FromArn != nil { 5704 objectKey := object.Key("FromArn") 5705 objectKey.String(*v.FromArn) 5706 } 5707 5708 if v.RawMessage != nil { 5709 objectKey := object.Key("RawMessage") 5710 if err := awsAwsquery_serializeDocumentRawMessage(v.RawMessage, objectKey); err != nil { 5711 return err 5712 } 5713 } 5714 5715 if v.ReturnPathArn != nil { 5716 objectKey := object.Key("ReturnPathArn") 5717 objectKey.String(*v.ReturnPathArn) 5718 } 5719 5720 if v.Source != nil { 5721 objectKey := object.Key("Source") 5722 objectKey.String(*v.Source) 5723 } 5724 5725 if v.SourceArn != nil { 5726 objectKey := object.Key("SourceArn") 5727 objectKey.String(*v.SourceArn) 5728 } 5729 5730 if v.Tags != nil { 5731 objectKey := object.Key("Tags") 5732 if err := awsAwsquery_serializeDocumentMessageTagList(v.Tags, objectKey); err != nil { 5733 return err 5734 } 5735 } 5736 5737 return nil 5738} 5739 5740func awsAwsquery_serializeOpDocumentSendTemplatedEmailInput(v *SendTemplatedEmailInput, value query.Value) error { 5741 object := value.Object() 5742 _ = object 5743 5744 if v.ConfigurationSetName != nil { 5745 objectKey := object.Key("ConfigurationSetName") 5746 objectKey.String(*v.ConfigurationSetName) 5747 } 5748 5749 if v.Destination != nil { 5750 objectKey := object.Key("Destination") 5751 if err := awsAwsquery_serializeDocumentDestination(v.Destination, objectKey); err != nil { 5752 return err 5753 } 5754 } 5755 5756 if v.ReplyToAddresses != nil { 5757 objectKey := object.Key("ReplyToAddresses") 5758 if err := awsAwsquery_serializeDocumentAddressList(v.ReplyToAddresses, objectKey); err != nil { 5759 return err 5760 } 5761 } 5762 5763 if v.ReturnPath != nil { 5764 objectKey := object.Key("ReturnPath") 5765 objectKey.String(*v.ReturnPath) 5766 } 5767 5768 if v.ReturnPathArn != nil { 5769 objectKey := object.Key("ReturnPathArn") 5770 objectKey.String(*v.ReturnPathArn) 5771 } 5772 5773 if v.Source != nil { 5774 objectKey := object.Key("Source") 5775 objectKey.String(*v.Source) 5776 } 5777 5778 if v.SourceArn != nil { 5779 objectKey := object.Key("SourceArn") 5780 objectKey.String(*v.SourceArn) 5781 } 5782 5783 if v.Tags != nil { 5784 objectKey := object.Key("Tags") 5785 if err := awsAwsquery_serializeDocumentMessageTagList(v.Tags, objectKey); err != nil { 5786 return err 5787 } 5788 } 5789 5790 if v.Template != nil { 5791 objectKey := object.Key("Template") 5792 objectKey.String(*v.Template) 5793 } 5794 5795 if v.TemplateArn != nil { 5796 objectKey := object.Key("TemplateArn") 5797 objectKey.String(*v.TemplateArn) 5798 } 5799 5800 if v.TemplateData != nil { 5801 objectKey := object.Key("TemplateData") 5802 objectKey.String(*v.TemplateData) 5803 } 5804 5805 return nil 5806} 5807 5808func awsAwsquery_serializeOpDocumentSetActiveReceiptRuleSetInput(v *SetActiveReceiptRuleSetInput, value query.Value) error { 5809 object := value.Object() 5810 _ = object 5811 5812 if v.RuleSetName != nil { 5813 objectKey := object.Key("RuleSetName") 5814 objectKey.String(*v.RuleSetName) 5815 } 5816 5817 return nil 5818} 5819 5820func awsAwsquery_serializeOpDocumentSetIdentityDkimEnabledInput(v *SetIdentityDkimEnabledInput, value query.Value) error { 5821 object := value.Object() 5822 _ = object 5823 5824 if v.DkimEnabled { 5825 objectKey := object.Key("DkimEnabled") 5826 objectKey.Boolean(v.DkimEnabled) 5827 } 5828 5829 if v.Identity != nil { 5830 objectKey := object.Key("Identity") 5831 objectKey.String(*v.Identity) 5832 } 5833 5834 return nil 5835} 5836 5837func awsAwsquery_serializeOpDocumentSetIdentityFeedbackForwardingEnabledInput(v *SetIdentityFeedbackForwardingEnabledInput, value query.Value) error { 5838 object := value.Object() 5839 _ = object 5840 5841 if v.ForwardingEnabled { 5842 objectKey := object.Key("ForwardingEnabled") 5843 objectKey.Boolean(v.ForwardingEnabled) 5844 } 5845 5846 if v.Identity != nil { 5847 objectKey := object.Key("Identity") 5848 objectKey.String(*v.Identity) 5849 } 5850 5851 return nil 5852} 5853 5854func awsAwsquery_serializeOpDocumentSetIdentityHeadersInNotificationsEnabledInput(v *SetIdentityHeadersInNotificationsEnabledInput, value query.Value) error { 5855 object := value.Object() 5856 _ = object 5857 5858 if v.Enabled { 5859 objectKey := object.Key("Enabled") 5860 objectKey.Boolean(v.Enabled) 5861 } 5862 5863 if v.Identity != nil { 5864 objectKey := object.Key("Identity") 5865 objectKey.String(*v.Identity) 5866 } 5867 5868 if len(v.NotificationType) > 0 { 5869 objectKey := object.Key("NotificationType") 5870 objectKey.String(string(v.NotificationType)) 5871 } 5872 5873 return nil 5874} 5875 5876func awsAwsquery_serializeOpDocumentSetIdentityMailFromDomainInput(v *SetIdentityMailFromDomainInput, value query.Value) error { 5877 object := value.Object() 5878 _ = object 5879 5880 if len(v.BehaviorOnMXFailure) > 0 { 5881 objectKey := object.Key("BehaviorOnMXFailure") 5882 objectKey.String(string(v.BehaviorOnMXFailure)) 5883 } 5884 5885 if v.Identity != nil { 5886 objectKey := object.Key("Identity") 5887 objectKey.String(*v.Identity) 5888 } 5889 5890 if v.MailFromDomain != nil { 5891 objectKey := object.Key("MailFromDomain") 5892 objectKey.String(*v.MailFromDomain) 5893 } 5894 5895 return nil 5896} 5897 5898func awsAwsquery_serializeOpDocumentSetIdentityNotificationTopicInput(v *SetIdentityNotificationTopicInput, value query.Value) error { 5899 object := value.Object() 5900 _ = object 5901 5902 if v.Identity != nil { 5903 objectKey := object.Key("Identity") 5904 objectKey.String(*v.Identity) 5905 } 5906 5907 if len(v.NotificationType) > 0 { 5908 objectKey := object.Key("NotificationType") 5909 objectKey.String(string(v.NotificationType)) 5910 } 5911 5912 if v.SnsTopic != nil { 5913 objectKey := object.Key("SnsTopic") 5914 objectKey.String(*v.SnsTopic) 5915 } 5916 5917 return nil 5918} 5919 5920func awsAwsquery_serializeOpDocumentSetReceiptRulePositionInput(v *SetReceiptRulePositionInput, value query.Value) error { 5921 object := value.Object() 5922 _ = object 5923 5924 if v.After != nil { 5925 objectKey := object.Key("After") 5926 objectKey.String(*v.After) 5927 } 5928 5929 if v.RuleName != nil { 5930 objectKey := object.Key("RuleName") 5931 objectKey.String(*v.RuleName) 5932 } 5933 5934 if v.RuleSetName != nil { 5935 objectKey := object.Key("RuleSetName") 5936 objectKey.String(*v.RuleSetName) 5937 } 5938 5939 return nil 5940} 5941 5942func awsAwsquery_serializeOpDocumentTestRenderTemplateInput(v *TestRenderTemplateInput, value query.Value) error { 5943 object := value.Object() 5944 _ = object 5945 5946 if v.TemplateData != nil { 5947 objectKey := object.Key("TemplateData") 5948 objectKey.String(*v.TemplateData) 5949 } 5950 5951 if v.TemplateName != nil { 5952 objectKey := object.Key("TemplateName") 5953 objectKey.String(*v.TemplateName) 5954 } 5955 5956 return nil 5957} 5958 5959func awsAwsquery_serializeOpDocumentUpdateAccountSendingEnabledInput(v *UpdateAccountSendingEnabledInput, value query.Value) error { 5960 object := value.Object() 5961 _ = object 5962 5963 if v.Enabled { 5964 objectKey := object.Key("Enabled") 5965 objectKey.Boolean(v.Enabled) 5966 } 5967 5968 return nil 5969} 5970 5971func awsAwsquery_serializeOpDocumentUpdateConfigurationSetEventDestinationInput(v *UpdateConfigurationSetEventDestinationInput, value query.Value) error { 5972 object := value.Object() 5973 _ = object 5974 5975 if v.ConfigurationSetName != nil { 5976 objectKey := object.Key("ConfigurationSetName") 5977 objectKey.String(*v.ConfigurationSetName) 5978 } 5979 5980 if v.EventDestination != nil { 5981 objectKey := object.Key("EventDestination") 5982 if err := awsAwsquery_serializeDocumentEventDestination(v.EventDestination, objectKey); err != nil { 5983 return err 5984 } 5985 } 5986 5987 return nil 5988} 5989 5990func awsAwsquery_serializeOpDocumentUpdateConfigurationSetReputationMetricsEnabledInput(v *UpdateConfigurationSetReputationMetricsEnabledInput, value query.Value) error { 5991 object := value.Object() 5992 _ = object 5993 5994 if v.ConfigurationSetName != nil { 5995 objectKey := object.Key("ConfigurationSetName") 5996 objectKey.String(*v.ConfigurationSetName) 5997 } 5998 5999 if v.Enabled { 6000 objectKey := object.Key("Enabled") 6001 objectKey.Boolean(v.Enabled) 6002 } 6003 6004 return nil 6005} 6006 6007func awsAwsquery_serializeOpDocumentUpdateConfigurationSetSendingEnabledInput(v *UpdateConfigurationSetSendingEnabledInput, value query.Value) error { 6008 object := value.Object() 6009 _ = object 6010 6011 if v.ConfigurationSetName != nil { 6012 objectKey := object.Key("ConfigurationSetName") 6013 objectKey.String(*v.ConfigurationSetName) 6014 } 6015 6016 if v.Enabled { 6017 objectKey := object.Key("Enabled") 6018 objectKey.Boolean(v.Enabled) 6019 } 6020 6021 return nil 6022} 6023 6024func awsAwsquery_serializeOpDocumentUpdateConfigurationSetTrackingOptionsInput(v *UpdateConfigurationSetTrackingOptionsInput, value query.Value) error { 6025 object := value.Object() 6026 _ = object 6027 6028 if v.ConfigurationSetName != nil { 6029 objectKey := object.Key("ConfigurationSetName") 6030 objectKey.String(*v.ConfigurationSetName) 6031 } 6032 6033 if v.TrackingOptions != nil { 6034 objectKey := object.Key("TrackingOptions") 6035 if err := awsAwsquery_serializeDocumentTrackingOptions(v.TrackingOptions, objectKey); err != nil { 6036 return err 6037 } 6038 } 6039 6040 return nil 6041} 6042 6043func awsAwsquery_serializeOpDocumentUpdateCustomVerificationEmailTemplateInput(v *UpdateCustomVerificationEmailTemplateInput, value query.Value) error { 6044 object := value.Object() 6045 _ = object 6046 6047 if v.FailureRedirectionURL != nil { 6048 objectKey := object.Key("FailureRedirectionURL") 6049 objectKey.String(*v.FailureRedirectionURL) 6050 } 6051 6052 if v.FromEmailAddress != nil { 6053 objectKey := object.Key("FromEmailAddress") 6054 objectKey.String(*v.FromEmailAddress) 6055 } 6056 6057 if v.SuccessRedirectionURL != nil { 6058 objectKey := object.Key("SuccessRedirectionURL") 6059 objectKey.String(*v.SuccessRedirectionURL) 6060 } 6061 6062 if v.TemplateContent != nil { 6063 objectKey := object.Key("TemplateContent") 6064 objectKey.String(*v.TemplateContent) 6065 } 6066 6067 if v.TemplateName != nil { 6068 objectKey := object.Key("TemplateName") 6069 objectKey.String(*v.TemplateName) 6070 } 6071 6072 if v.TemplateSubject != nil { 6073 objectKey := object.Key("TemplateSubject") 6074 objectKey.String(*v.TemplateSubject) 6075 } 6076 6077 return nil 6078} 6079 6080func awsAwsquery_serializeOpDocumentUpdateReceiptRuleInput(v *UpdateReceiptRuleInput, value query.Value) error { 6081 object := value.Object() 6082 _ = object 6083 6084 if v.Rule != nil { 6085 objectKey := object.Key("Rule") 6086 if err := awsAwsquery_serializeDocumentReceiptRule(v.Rule, objectKey); err != nil { 6087 return err 6088 } 6089 } 6090 6091 if v.RuleSetName != nil { 6092 objectKey := object.Key("RuleSetName") 6093 objectKey.String(*v.RuleSetName) 6094 } 6095 6096 return nil 6097} 6098 6099func awsAwsquery_serializeOpDocumentUpdateTemplateInput(v *UpdateTemplateInput, value query.Value) error { 6100 object := value.Object() 6101 _ = object 6102 6103 if v.Template != nil { 6104 objectKey := object.Key("Template") 6105 if err := awsAwsquery_serializeDocumentTemplate(v.Template, objectKey); err != nil { 6106 return err 6107 } 6108 } 6109 6110 return nil 6111} 6112 6113func awsAwsquery_serializeOpDocumentVerifyDomainDkimInput(v *VerifyDomainDkimInput, value query.Value) error { 6114 object := value.Object() 6115 _ = object 6116 6117 if v.Domain != nil { 6118 objectKey := object.Key("Domain") 6119 objectKey.String(*v.Domain) 6120 } 6121 6122 return nil 6123} 6124 6125func awsAwsquery_serializeOpDocumentVerifyDomainIdentityInput(v *VerifyDomainIdentityInput, value query.Value) error { 6126 object := value.Object() 6127 _ = object 6128 6129 if v.Domain != nil { 6130 objectKey := object.Key("Domain") 6131 objectKey.String(*v.Domain) 6132 } 6133 6134 return nil 6135} 6136 6137func awsAwsquery_serializeOpDocumentVerifyEmailAddressInput(v *VerifyEmailAddressInput, value query.Value) error { 6138 object := value.Object() 6139 _ = object 6140 6141 if v.EmailAddress != nil { 6142 objectKey := object.Key("EmailAddress") 6143 objectKey.String(*v.EmailAddress) 6144 } 6145 6146 return nil 6147} 6148 6149func awsAwsquery_serializeOpDocumentVerifyEmailIdentityInput(v *VerifyEmailIdentityInput, value query.Value) error { 6150 object := value.Object() 6151 _ = object 6152 6153 if v.EmailAddress != nil { 6154 objectKey := object.Key("EmailAddress") 6155 objectKey.String(*v.EmailAddress) 6156 } 6157 6158 return nil 6159} 6160