1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package customerprofiles 4 5import ( 6 "bytes" 7 "context" 8 "fmt" 9 "github.com/aws/aws-sdk-go-v2/service/customerprofiles/types" 10 smithy "github.com/aws/smithy-go" 11 "github.com/aws/smithy-go/encoding/httpbinding" 12 smithyjson "github.com/aws/smithy-go/encoding/json" 13 "github.com/aws/smithy-go/middleware" 14 smithyhttp "github.com/aws/smithy-go/transport/http" 15) 16 17type awsRestjson1_serializeOpAddProfileKey struct { 18} 19 20func (*awsRestjson1_serializeOpAddProfileKey) ID() string { 21 return "OperationSerializer" 22} 23 24func (m *awsRestjson1_serializeOpAddProfileKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 25 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 26) { 27 request, ok := in.Request.(*smithyhttp.Request) 28 if !ok { 29 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 30 } 31 32 input, ok := in.Parameters.(*AddProfileKeyInput) 33 _ = input 34 if !ok { 35 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 36 } 37 38 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/profiles/keys") 39 request.URL.Path = opPath 40 if len(request.URL.RawQuery) > 0 { 41 request.URL.RawQuery = "&" + opQuery 42 } else { 43 request.URL.RawQuery = opQuery 44 } 45 46 request.Method = "POST" 47 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 48 if err != nil { 49 return out, metadata, &smithy.SerializationError{Err: err} 50 } 51 52 if err := awsRestjson1_serializeOpHttpBindingsAddProfileKeyInput(input, restEncoder); err != nil { 53 return out, metadata, &smithy.SerializationError{Err: err} 54 } 55 56 restEncoder.SetHeader("Content-Type").String("application/json") 57 58 jsonEncoder := smithyjson.NewEncoder() 59 if err := awsRestjson1_serializeOpDocumentAddProfileKeyInput(input, jsonEncoder.Value); err != nil { 60 return out, metadata, &smithy.SerializationError{Err: err} 61 } 62 63 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 64 return out, metadata, &smithy.SerializationError{Err: err} 65 } 66 67 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 68 return out, metadata, &smithy.SerializationError{Err: err} 69 } 70 in.Request = request 71 72 return next.HandleSerialize(ctx, in) 73} 74func awsRestjson1_serializeOpHttpBindingsAddProfileKeyInput(v *AddProfileKeyInput, encoder *httpbinding.Encoder) error { 75 if v == nil { 76 return fmt.Errorf("unsupported serialization of nil %T", v) 77 } 78 79 if v.DomainName == nil || len(*v.DomainName) == 0 { 80 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 81 } 82 if v.DomainName != nil { 83 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 84 return err 85 } 86 } 87 88 return nil 89} 90 91func awsRestjson1_serializeOpDocumentAddProfileKeyInput(v *AddProfileKeyInput, value smithyjson.Value) error { 92 object := value.Object() 93 defer object.Close() 94 95 if v.KeyName != nil { 96 ok := object.Key("KeyName") 97 ok.String(*v.KeyName) 98 } 99 100 if v.ProfileId != nil { 101 ok := object.Key("ProfileId") 102 ok.String(*v.ProfileId) 103 } 104 105 if v.Values != nil { 106 ok := object.Key("Values") 107 if err := awsRestjson1_serializeDocumentRequestValueList(v.Values, ok); err != nil { 108 return err 109 } 110 } 111 112 return nil 113} 114 115type awsRestjson1_serializeOpCreateDomain struct { 116} 117 118func (*awsRestjson1_serializeOpCreateDomain) ID() string { 119 return "OperationSerializer" 120} 121 122func (m *awsRestjson1_serializeOpCreateDomain) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 123 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 124) { 125 request, ok := in.Request.(*smithyhttp.Request) 126 if !ok { 127 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 128 } 129 130 input, ok := in.Parameters.(*CreateDomainInput) 131 _ = input 132 if !ok { 133 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 134 } 135 136 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}") 137 request.URL.Path = opPath 138 if len(request.URL.RawQuery) > 0 { 139 request.URL.RawQuery = "&" + opQuery 140 } else { 141 request.URL.RawQuery = opQuery 142 } 143 144 request.Method = "POST" 145 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 146 if err != nil { 147 return out, metadata, &smithy.SerializationError{Err: err} 148 } 149 150 if err := awsRestjson1_serializeOpHttpBindingsCreateDomainInput(input, restEncoder); err != nil { 151 return out, metadata, &smithy.SerializationError{Err: err} 152 } 153 154 restEncoder.SetHeader("Content-Type").String("application/json") 155 156 jsonEncoder := smithyjson.NewEncoder() 157 if err := awsRestjson1_serializeOpDocumentCreateDomainInput(input, jsonEncoder.Value); err != nil { 158 return out, metadata, &smithy.SerializationError{Err: err} 159 } 160 161 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 162 return out, metadata, &smithy.SerializationError{Err: err} 163 } 164 165 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 166 return out, metadata, &smithy.SerializationError{Err: err} 167 } 168 in.Request = request 169 170 return next.HandleSerialize(ctx, in) 171} 172func awsRestjson1_serializeOpHttpBindingsCreateDomainInput(v *CreateDomainInput, encoder *httpbinding.Encoder) error { 173 if v == nil { 174 return fmt.Errorf("unsupported serialization of nil %T", v) 175 } 176 177 if v.DomainName == nil || len(*v.DomainName) == 0 { 178 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 179 } 180 if v.DomainName != nil { 181 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 182 return err 183 } 184 } 185 186 return nil 187} 188 189func awsRestjson1_serializeOpDocumentCreateDomainInput(v *CreateDomainInput, value smithyjson.Value) error { 190 object := value.Object() 191 defer object.Close() 192 193 if v.DeadLetterQueueUrl != nil { 194 ok := object.Key("DeadLetterQueueUrl") 195 ok.String(*v.DeadLetterQueueUrl) 196 } 197 198 if v.DefaultEncryptionKey != nil { 199 ok := object.Key("DefaultEncryptionKey") 200 ok.String(*v.DefaultEncryptionKey) 201 } 202 203 if v.DefaultExpirationDays != nil { 204 ok := object.Key("DefaultExpirationDays") 205 ok.Integer(*v.DefaultExpirationDays) 206 } 207 208 if v.Tags != nil { 209 ok := object.Key("Tags") 210 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 211 return err 212 } 213 } 214 215 return nil 216} 217 218type awsRestjson1_serializeOpCreateProfile struct { 219} 220 221func (*awsRestjson1_serializeOpCreateProfile) ID() string { 222 return "OperationSerializer" 223} 224 225func (m *awsRestjson1_serializeOpCreateProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 226 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 227) { 228 request, ok := in.Request.(*smithyhttp.Request) 229 if !ok { 230 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 231 } 232 233 input, ok := in.Parameters.(*CreateProfileInput) 234 _ = input 235 if !ok { 236 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 237 } 238 239 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/profiles") 240 request.URL.Path = opPath 241 if len(request.URL.RawQuery) > 0 { 242 request.URL.RawQuery = "&" + opQuery 243 } else { 244 request.URL.RawQuery = opQuery 245 } 246 247 request.Method = "POST" 248 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 249 if err != nil { 250 return out, metadata, &smithy.SerializationError{Err: err} 251 } 252 253 if err := awsRestjson1_serializeOpHttpBindingsCreateProfileInput(input, restEncoder); err != nil { 254 return out, metadata, &smithy.SerializationError{Err: err} 255 } 256 257 restEncoder.SetHeader("Content-Type").String("application/json") 258 259 jsonEncoder := smithyjson.NewEncoder() 260 if err := awsRestjson1_serializeOpDocumentCreateProfileInput(input, jsonEncoder.Value); err != nil { 261 return out, metadata, &smithy.SerializationError{Err: err} 262 } 263 264 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 265 return out, metadata, &smithy.SerializationError{Err: err} 266 } 267 268 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 269 return out, metadata, &smithy.SerializationError{Err: err} 270 } 271 in.Request = request 272 273 return next.HandleSerialize(ctx, in) 274} 275func awsRestjson1_serializeOpHttpBindingsCreateProfileInput(v *CreateProfileInput, encoder *httpbinding.Encoder) error { 276 if v == nil { 277 return fmt.Errorf("unsupported serialization of nil %T", v) 278 } 279 280 if v.DomainName == nil || len(*v.DomainName) == 0 { 281 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 282 } 283 if v.DomainName != nil { 284 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 285 return err 286 } 287 } 288 289 return nil 290} 291 292func awsRestjson1_serializeOpDocumentCreateProfileInput(v *CreateProfileInput, value smithyjson.Value) error { 293 object := value.Object() 294 defer object.Close() 295 296 if v.AccountNumber != nil { 297 ok := object.Key("AccountNumber") 298 ok.String(*v.AccountNumber) 299 } 300 301 if v.AdditionalInformation != nil { 302 ok := object.Key("AdditionalInformation") 303 ok.String(*v.AdditionalInformation) 304 } 305 306 if v.Address != nil { 307 ok := object.Key("Address") 308 if err := awsRestjson1_serializeDocumentAddress(v.Address, ok); err != nil { 309 return err 310 } 311 } 312 313 if v.Attributes != nil { 314 ok := object.Key("Attributes") 315 if err := awsRestjson1_serializeDocumentAttributes(v.Attributes, ok); err != nil { 316 return err 317 } 318 } 319 320 if v.BillingAddress != nil { 321 ok := object.Key("BillingAddress") 322 if err := awsRestjson1_serializeDocumentAddress(v.BillingAddress, ok); err != nil { 323 return err 324 } 325 } 326 327 if v.BirthDate != nil { 328 ok := object.Key("BirthDate") 329 ok.String(*v.BirthDate) 330 } 331 332 if v.BusinessEmailAddress != nil { 333 ok := object.Key("BusinessEmailAddress") 334 ok.String(*v.BusinessEmailAddress) 335 } 336 337 if v.BusinessName != nil { 338 ok := object.Key("BusinessName") 339 ok.String(*v.BusinessName) 340 } 341 342 if v.BusinessPhoneNumber != nil { 343 ok := object.Key("BusinessPhoneNumber") 344 ok.String(*v.BusinessPhoneNumber) 345 } 346 347 if v.EmailAddress != nil { 348 ok := object.Key("EmailAddress") 349 ok.String(*v.EmailAddress) 350 } 351 352 if v.FirstName != nil { 353 ok := object.Key("FirstName") 354 ok.String(*v.FirstName) 355 } 356 357 if len(v.Gender) > 0 { 358 ok := object.Key("Gender") 359 ok.String(string(v.Gender)) 360 } 361 362 if v.HomePhoneNumber != nil { 363 ok := object.Key("HomePhoneNumber") 364 ok.String(*v.HomePhoneNumber) 365 } 366 367 if v.LastName != nil { 368 ok := object.Key("LastName") 369 ok.String(*v.LastName) 370 } 371 372 if v.MailingAddress != nil { 373 ok := object.Key("MailingAddress") 374 if err := awsRestjson1_serializeDocumentAddress(v.MailingAddress, ok); err != nil { 375 return err 376 } 377 } 378 379 if v.MiddleName != nil { 380 ok := object.Key("MiddleName") 381 ok.String(*v.MiddleName) 382 } 383 384 if v.MobilePhoneNumber != nil { 385 ok := object.Key("MobilePhoneNumber") 386 ok.String(*v.MobilePhoneNumber) 387 } 388 389 if len(v.PartyType) > 0 { 390 ok := object.Key("PartyType") 391 ok.String(string(v.PartyType)) 392 } 393 394 if v.PersonalEmailAddress != nil { 395 ok := object.Key("PersonalEmailAddress") 396 ok.String(*v.PersonalEmailAddress) 397 } 398 399 if v.PhoneNumber != nil { 400 ok := object.Key("PhoneNumber") 401 ok.String(*v.PhoneNumber) 402 } 403 404 if v.ShippingAddress != nil { 405 ok := object.Key("ShippingAddress") 406 if err := awsRestjson1_serializeDocumentAddress(v.ShippingAddress, ok); err != nil { 407 return err 408 } 409 } 410 411 return nil 412} 413 414type awsRestjson1_serializeOpDeleteDomain struct { 415} 416 417func (*awsRestjson1_serializeOpDeleteDomain) ID() string { 418 return "OperationSerializer" 419} 420 421func (m *awsRestjson1_serializeOpDeleteDomain) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 422 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 423) { 424 request, ok := in.Request.(*smithyhttp.Request) 425 if !ok { 426 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 427 } 428 429 input, ok := in.Parameters.(*DeleteDomainInput) 430 _ = input 431 if !ok { 432 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 433 } 434 435 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}") 436 request.URL.Path = opPath 437 if len(request.URL.RawQuery) > 0 { 438 request.URL.RawQuery = "&" + opQuery 439 } else { 440 request.URL.RawQuery = opQuery 441 } 442 443 request.Method = "DELETE" 444 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 445 if err != nil { 446 return out, metadata, &smithy.SerializationError{Err: err} 447 } 448 449 if err := awsRestjson1_serializeOpHttpBindingsDeleteDomainInput(input, restEncoder); err != nil { 450 return out, metadata, &smithy.SerializationError{Err: err} 451 } 452 453 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 454 return out, metadata, &smithy.SerializationError{Err: err} 455 } 456 in.Request = request 457 458 return next.HandleSerialize(ctx, in) 459} 460func awsRestjson1_serializeOpHttpBindingsDeleteDomainInput(v *DeleteDomainInput, encoder *httpbinding.Encoder) error { 461 if v == nil { 462 return fmt.Errorf("unsupported serialization of nil %T", v) 463 } 464 465 if v.DomainName == nil || len(*v.DomainName) == 0 { 466 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 467 } 468 if v.DomainName != nil { 469 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 470 return err 471 } 472 } 473 474 return nil 475} 476 477type awsRestjson1_serializeOpDeleteIntegration struct { 478} 479 480func (*awsRestjson1_serializeOpDeleteIntegration) ID() string { 481 return "OperationSerializer" 482} 483 484func (m *awsRestjson1_serializeOpDeleteIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 485 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 486) { 487 request, ok := in.Request.(*smithyhttp.Request) 488 if !ok { 489 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 490 } 491 492 input, ok := in.Parameters.(*DeleteIntegrationInput) 493 _ = input 494 if !ok { 495 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 496 } 497 498 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/integrations/delete") 499 request.URL.Path = opPath 500 if len(request.URL.RawQuery) > 0 { 501 request.URL.RawQuery = "&" + opQuery 502 } else { 503 request.URL.RawQuery = opQuery 504 } 505 506 request.Method = "POST" 507 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 508 if err != nil { 509 return out, metadata, &smithy.SerializationError{Err: err} 510 } 511 512 if err := awsRestjson1_serializeOpHttpBindingsDeleteIntegrationInput(input, restEncoder); err != nil { 513 return out, metadata, &smithy.SerializationError{Err: err} 514 } 515 516 restEncoder.SetHeader("Content-Type").String("application/json") 517 518 jsonEncoder := smithyjson.NewEncoder() 519 if err := awsRestjson1_serializeOpDocumentDeleteIntegrationInput(input, jsonEncoder.Value); err != nil { 520 return out, metadata, &smithy.SerializationError{Err: err} 521 } 522 523 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 524 return out, metadata, &smithy.SerializationError{Err: err} 525 } 526 527 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 528 return out, metadata, &smithy.SerializationError{Err: err} 529 } 530 in.Request = request 531 532 return next.HandleSerialize(ctx, in) 533} 534func awsRestjson1_serializeOpHttpBindingsDeleteIntegrationInput(v *DeleteIntegrationInput, encoder *httpbinding.Encoder) error { 535 if v == nil { 536 return fmt.Errorf("unsupported serialization of nil %T", v) 537 } 538 539 if v.DomainName == nil || len(*v.DomainName) == 0 { 540 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 541 } 542 if v.DomainName != nil { 543 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 544 return err 545 } 546 } 547 548 return nil 549} 550 551func awsRestjson1_serializeOpDocumentDeleteIntegrationInput(v *DeleteIntegrationInput, value smithyjson.Value) error { 552 object := value.Object() 553 defer object.Close() 554 555 if v.Uri != nil { 556 ok := object.Key("Uri") 557 ok.String(*v.Uri) 558 } 559 560 return nil 561} 562 563type awsRestjson1_serializeOpDeleteProfile struct { 564} 565 566func (*awsRestjson1_serializeOpDeleteProfile) ID() string { 567 return "OperationSerializer" 568} 569 570func (m *awsRestjson1_serializeOpDeleteProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 571 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 572) { 573 request, ok := in.Request.(*smithyhttp.Request) 574 if !ok { 575 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 576 } 577 578 input, ok := in.Parameters.(*DeleteProfileInput) 579 _ = input 580 if !ok { 581 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 582 } 583 584 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/profiles/delete") 585 request.URL.Path = opPath 586 if len(request.URL.RawQuery) > 0 { 587 request.URL.RawQuery = "&" + opQuery 588 } else { 589 request.URL.RawQuery = opQuery 590 } 591 592 request.Method = "POST" 593 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 594 if err != nil { 595 return out, metadata, &smithy.SerializationError{Err: err} 596 } 597 598 if err := awsRestjson1_serializeOpHttpBindingsDeleteProfileInput(input, restEncoder); err != nil { 599 return out, metadata, &smithy.SerializationError{Err: err} 600 } 601 602 restEncoder.SetHeader("Content-Type").String("application/json") 603 604 jsonEncoder := smithyjson.NewEncoder() 605 if err := awsRestjson1_serializeOpDocumentDeleteProfileInput(input, jsonEncoder.Value); err != nil { 606 return out, metadata, &smithy.SerializationError{Err: err} 607 } 608 609 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 610 return out, metadata, &smithy.SerializationError{Err: err} 611 } 612 613 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 614 return out, metadata, &smithy.SerializationError{Err: err} 615 } 616 in.Request = request 617 618 return next.HandleSerialize(ctx, in) 619} 620func awsRestjson1_serializeOpHttpBindingsDeleteProfileInput(v *DeleteProfileInput, encoder *httpbinding.Encoder) error { 621 if v == nil { 622 return fmt.Errorf("unsupported serialization of nil %T", v) 623 } 624 625 if v.DomainName == nil || len(*v.DomainName) == 0 { 626 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 627 } 628 if v.DomainName != nil { 629 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 630 return err 631 } 632 } 633 634 return nil 635} 636 637func awsRestjson1_serializeOpDocumentDeleteProfileInput(v *DeleteProfileInput, value smithyjson.Value) error { 638 object := value.Object() 639 defer object.Close() 640 641 if v.ProfileId != nil { 642 ok := object.Key("ProfileId") 643 ok.String(*v.ProfileId) 644 } 645 646 return nil 647} 648 649type awsRestjson1_serializeOpDeleteProfileKey struct { 650} 651 652func (*awsRestjson1_serializeOpDeleteProfileKey) ID() string { 653 return "OperationSerializer" 654} 655 656func (m *awsRestjson1_serializeOpDeleteProfileKey) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 657 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 658) { 659 request, ok := in.Request.(*smithyhttp.Request) 660 if !ok { 661 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 662 } 663 664 input, ok := in.Parameters.(*DeleteProfileKeyInput) 665 _ = input 666 if !ok { 667 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 668 } 669 670 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/profiles/keys/delete") 671 request.URL.Path = opPath 672 if len(request.URL.RawQuery) > 0 { 673 request.URL.RawQuery = "&" + opQuery 674 } else { 675 request.URL.RawQuery = opQuery 676 } 677 678 request.Method = "POST" 679 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 680 if err != nil { 681 return out, metadata, &smithy.SerializationError{Err: err} 682 } 683 684 if err := awsRestjson1_serializeOpHttpBindingsDeleteProfileKeyInput(input, restEncoder); err != nil { 685 return out, metadata, &smithy.SerializationError{Err: err} 686 } 687 688 restEncoder.SetHeader("Content-Type").String("application/json") 689 690 jsonEncoder := smithyjson.NewEncoder() 691 if err := awsRestjson1_serializeOpDocumentDeleteProfileKeyInput(input, jsonEncoder.Value); err != nil { 692 return out, metadata, &smithy.SerializationError{Err: err} 693 } 694 695 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 696 return out, metadata, &smithy.SerializationError{Err: err} 697 } 698 699 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 700 return out, metadata, &smithy.SerializationError{Err: err} 701 } 702 in.Request = request 703 704 return next.HandleSerialize(ctx, in) 705} 706func awsRestjson1_serializeOpHttpBindingsDeleteProfileKeyInput(v *DeleteProfileKeyInput, encoder *httpbinding.Encoder) error { 707 if v == nil { 708 return fmt.Errorf("unsupported serialization of nil %T", v) 709 } 710 711 if v.DomainName == nil || len(*v.DomainName) == 0 { 712 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 713 } 714 if v.DomainName != nil { 715 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 716 return err 717 } 718 } 719 720 return nil 721} 722 723func awsRestjson1_serializeOpDocumentDeleteProfileKeyInput(v *DeleteProfileKeyInput, value smithyjson.Value) error { 724 object := value.Object() 725 defer object.Close() 726 727 if v.KeyName != nil { 728 ok := object.Key("KeyName") 729 ok.String(*v.KeyName) 730 } 731 732 if v.ProfileId != nil { 733 ok := object.Key("ProfileId") 734 ok.String(*v.ProfileId) 735 } 736 737 if v.Values != nil { 738 ok := object.Key("Values") 739 if err := awsRestjson1_serializeDocumentRequestValueList(v.Values, ok); err != nil { 740 return err 741 } 742 } 743 744 return nil 745} 746 747type awsRestjson1_serializeOpDeleteProfileObject struct { 748} 749 750func (*awsRestjson1_serializeOpDeleteProfileObject) ID() string { 751 return "OperationSerializer" 752} 753 754func (m *awsRestjson1_serializeOpDeleteProfileObject) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 755 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 756) { 757 request, ok := in.Request.(*smithyhttp.Request) 758 if !ok { 759 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 760 } 761 762 input, ok := in.Parameters.(*DeleteProfileObjectInput) 763 _ = input 764 if !ok { 765 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 766 } 767 768 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/profiles/objects/delete") 769 request.URL.Path = opPath 770 if len(request.URL.RawQuery) > 0 { 771 request.URL.RawQuery = "&" + opQuery 772 } else { 773 request.URL.RawQuery = opQuery 774 } 775 776 request.Method = "POST" 777 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 778 if err != nil { 779 return out, metadata, &smithy.SerializationError{Err: err} 780 } 781 782 if err := awsRestjson1_serializeOpHttpBindingsDeleteProfileObjectInput(input, restEncoder); err != nil { 783 return out, metadata, &smithy.SerializationError{Err: err} 784 } 785 786 restEncoder.SetHeader("Content-Type").String("application/json") 787 788 jsonEncoder := smithyjson.NewEncoder() 789 if err := awsRestjson1_serializeOpDocumentDeleteProfileObjectInput(input, jsonEncoder.Value); err != nil { 790 return out, metadata, &smithy.SerializationError{Err: err} 791 } 792 793 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 794 return out, metadata, &smithy.SerializationError{Err: err} 795 } 796 797 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 798 return out, metadata, &smithy.SerializationError{Err: err} 799 } 800 in.Request = request 801 802 return next.HandleSerialize(ctx, in) 803} 804func awsRestjson1_serializeOpHttpBindingsDeleteProfileObjectInput(v *DeleteProfileObjectInput, encoder *httpbinding.Encoder) error { 805 if v == nil { 806 return fmt.Errorf("unsupported serialization of nil %T", v) 807 } 808 809 if v.DomainName == nil || len(*v.DomainName) == 0 { 810 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 811 } 812 if v.DomainName != nil { 813 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 814 return err 815 } 816 } 817 818 return nil 819} 820 821func awsRestjson1_serializeOpDocumentDeleteProfileObjectInput(v *DeleteProfileObjectInput, value smithyjson.Value) error { 822 object := value.Object() 823 defer object.Close() 824 825 if v.ObjectTypeName != nil { 826 ok := object.Key("ObjectTypeName") 827 ok.String(*v.ObjectTypeName) 828 } 829 830 if v.ProfileId != nil { 831 ok := object.Key("ProfileId") 832 ok.String(*v.ProfileId) 833 } 834 835 if v.ProfileObjectUniqueKey != nil { 836 ok := object.Key("ProfileObjectUniqueKey") 837 ok.String(*v.ProfileObjectUniqueKey) 838 } 839 840 return nil 841} 842 843type awsRestjson1_serializeOpDeleteProfileObjectType struct { 844} 845 846func (*awsRestjson1_serializeOpDeleteProfileObjectType) ID() string { 847 return "OperationSerializer" 848} 849 850func (m *awsRestjson1_serializeOpDeleteProfileObjectType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 851 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 852) { 853 request, ok := in.Request.(*smithyhttp.Request) 854 if !ok { 855 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 856 } 857 858 input, ok := in.Parameters.(*DeleteProfileObjectTypeInput) 859 _ = input 860 if !ok { 861 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 862 } 863 864 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/object-types/{ObjectTypeName}") 865 request.URL.Path = opPath 866 if len(request.URL.RawQuery) > 0 { 867 request.URL.RawQuery = "&" + opQuery 868 } else { 869 request.URL.RawQuery = opQuery 870 } 871 872 request.Method = "DELETE" 873 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 874 if err != nil { 875 return out, metadata, &smithy.SerializationError{Err: err} 876 } 877 878 if err := awsRestjson1_serializeOpHttpBindingsDeleteProfileObjectTypeInput(input, restEncoder); err != nil { 879 return out, metadata, &smithy.SerializationError{Err: err} 880 } 881 882 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 883 return out, metadata, &smithy.SerializationError{Err: err} 884 } 885 in.Request = request 886 887 return next.HandleSerialize(ctx, in) 888} 889func awsRestjson1_serializeOpHttpBindingsDeleteProfileObjectTypeInput(v *DeleteProfileObjectTypeInput, encoder *httpbinding.Encoder) error { 890 if v == nil { 891 return fmt.Errorf("unsupported serialization of nil %T", v) 892 } 893 894 if v.DomainName == nil || len(*v.DomainName) == 0 { 895 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 896 } 897 if v.DomainName != nil { 898 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 899 return err 900 } 901 } 902 903 if v.ObjectTypeName == nil || len(*v.ObjectTypeName) == 0 { 904 return &smithy.SerializationError{Err: fmt.Errorf("input member ObjectTypeName must not be empty")} 905 } 906 if v.ObjectTypeName != nil { 907 if err := encoder.SetURI("ObjectTypeName").String(*v.ObjectTypeName); err != nil { 908 return err 909 } 910 } 911 912 return nil 913} 914 915type awsRestjson1_serializeOpGetDomain struct { 916} 917 918func (*awsRestjson1_serializeOpGetDomain) ID() string { 919 return "OperationSerializer" 920} 921 922func (m *awsRestjson1_serializeOpGetDomain) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 923 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 924) { 925 request, ok := in.Request.(*smithyhttp.Request) 926 if !ok { 927 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 928 } 929 930 input, ok := in.Parameters.(*GetDomainInput) 931 _ = input 932 if !ok { 933 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 934 } 935 936 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}") 937 request.URL.Path = opPath 938 if len(request.URL.RawQuery) > 0 { 939 request.URL.RawQuery = "&" + opQuery 940 } else { 941 request.URL.RawQuery = opQuery 942 } 943 944 request.Method = "GET" 945 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 946 if err != nil { 947 return out, metadata, &smithy.SerializationError{Err: err} 948 } 949 950 if err := awsRestjson1_serializeOpHttpBindingsGetDomainInput(input, restEncoder); err != nil { 951 return out, metadata, &smithy.SerializationError{Err: err} 952 } 953 954 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 955 return out, metadata, &smithy.SerializationError{Err: err} 956 } 957 in.Request = request 958 959 return next.HandleSerialize(ctx, in) 960} 961func awsRestjson1_serializeOpHttpBindingsGetDomainInput(v *GetDomainInput, encoder *httpbinding.Encoder) error { 962 if v == nil { 963 return fmt.Errorf("unsupported serialization of nil %T", v) 964 } 965 966 if v.DomainName == nil || len(*v.DomainName) == 0 { 967 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 968 } 969 if v.DomainName != nil { 970 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 971 return err 972 } 973 } 974 975 return nil 976} 977 978type awsRestjson1_serializeOpGetIntegration struct { 979} 980 981func (*awsRestjson1_serializeOpGetIntegration) ID() string { 982 return "OperationSerializer" 983} 984 985func (m *awsRestjson1_serializeOpGetIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 986 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 987) { 988 request, ok := in.Request.(*smithyhttp.Request) 989 if !ok { 990 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 991 } 992 993 input, ok := in.Parameters.(*GetIntegrationInput) 994 _ = input 995 if !ok { 996 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 997 } 998 999 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/integrations") 1000 request.URL.Path = opPath 1001 if len(request.URL.RawQuery) > 0 { 1002 request.URL.RawQuery = "&" + opQuery 1003 } else { 1004 request.URL.RawQuery = opQuery 1005 } 1006 1007 request.Method = "POST" 1008 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1009 if err != nil { 1010 return out, metadata, &smithy.SerializationError{Err: err} 1011 } 1012 1013 if err := awsRestjson1_serializeOpHttpBindingsGetIntegrationInput(input, restEncoder); err != nil { 1014 return out, metadata, &smithy.SerializationError{Err: err} 1015 } 1016 1017 restEncoder.SetHeader("Content-Type").String("application/json") 1018 1019 jsonEncoder := smithyjson.NewEncoder() 1020 if err := awsRestjson1_serializeOpDocumentGetIntegrationInput(input, jsonEncoder.Value); err != nil { 1021 return out, metadata, &smithy.SerializationError{Err: err} 1022 } 1023 1024 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1025 return out, metadata, &smithy.SerializationError{Err: err} 1026 } 1027 1028 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1029 return out, metadata, &smithy.SerializationError{Err: err} 1030 } 1031 in.Request = request 1032 1033 return next.HandleSerialize(ctx, in) 1034} 1035func awsRestjson1_serializeOpHttpBindingsGetIntegrationInput(v *GetIntegrationInput, encoder *httpbinding.Encoder) error { 1036 if v == nil { 1037 return fmt.Errorf("unsupported serialization of nil %T", v) 1038 } 1039 1040 if v.DomainName == nil || len(*v.DomainName) == 0 { 1041 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 1042 } 1043 if v.DomainName != nil { 1044 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 1045 return err 1046 } 1047 } 1048 1049 return nil 1050} 1051 1052func awsRestjson1_serializeOpDocumentGetIntegrationInput(v *GetIntegrationInput, value smithyjson.Value) error { 1053 object := value.Object() 1054 defer object.Close() 1055 1056 if v.Uri != nil { 1057 ok := object.Key("Uri") 1058 ok.String(*v.Uri) 1059 } 1060 1061 return nil 1062} 1063 1064type awsRestjson1_serializeOpGetProfileObjectType struct { 1065} 1066 1067func (*awsRestjson1_serializeOpGetProfileObjectType) ID() string { 1068 return "OperationSerializer" 1069} 1070 1071func (m *awsRestjson1_serializeOpGetProfileObjectType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1072 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1073) { 1074 request, ok := in.Request.(*smithyhttp.Request) 1075 if !ok { 1076 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1077 } 1078 1079 input, ok := in.Parameters.(*GetProfileObjectTypeInput) 1080 _ = input 1081 if !ok { 1082 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1083 } 1084 1085 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/object-types/{ObjectTypeName}") 1086 request.URL.Path = opPath 1087 if len(request.URL.RawQuery) > 0 { 1088 request.URL.RawQuery = "&" + opQuery 1089 } else { 1090 request.URL.RawQuery = opQuery 1091 } 1092 1093 request.Method = "GET" 1094 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1095 if err != nil { 1096 return out, metadata, &smithy.SerializationError{Err: err} 1097 } 1098 1099 if err := awsRestjson1_serializeOpHttpBindingsGetProfileObjectTypeInput(input, restEncoder); err != nil { 1100 return out, metadata, &smithy.SerializationError{Err: err} 1101 } 1102 1103 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1104 return out, metadata, &smithy.SerializationError{Err: err} 1105 } 1106 in.Request = request 1107 1108 return next.HandleSerialize(ctx, in) 1109} 1110func awsRestjson1_serializeOpHttpBindingsGetProfileObjectTypeInput(v *GetProfileObjectTypeInput, encoder *httpbinding.Encoder) error { 1111 if v == nil { 1112 return fmt.Errorf("unsupported serialization of nil %T", v) 1113 } 1114 1115 if v.DomainName == nil || len(*v.DomainName) == 0 { 1116 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 1117 } 1118 if v.DomainName != nil { 1119 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 1120 return err 1121 } 1122 } 1123 1124 if v.ObjectTypeName == nil || len(*v.ObjectTypeName) == 0 { 1125 return &smithy.SerializationError{Err: fmt.Errorf("input member ObjectTypeName must not be empty")} 1126 } 1127 if v.ObjectTypeName != nil { 1128 if err := encoder.SetURI("ObjectTypeName").String(*v.ObjectTypeName); err != nil { 1129 return err 1130 } 1131 } 1132 1133 return nil 1134} 1135 1136type awsRestjson1_serializeOpGetProfileObjectTypeTemplate struct { 1137} 1138 1139func (*awsRestjson1_serializeOpGetProfileObjectTypeTemplate) ID() string { 1140 return "OperationSerializer" 1141} 1142 1143func (m *awsRestjson1_serializeOpGetProfileObjectTypeTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1144 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1145) { 1146 request, ok := in.Request.(*smithyhttp.Request) 1147 if !ok { 1148 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1149 } 1150 1151 input, ok := in.Parameters.(*GetProfileObjectTypeTemplateInput) 1152 _ = input 1153 if !ok { 1154 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1155 } 1156 1157 opPath, opQuery := httpbinding.SplitURI("/templates/{TemplateId}") 1158 request.URL.Path = opPath 1159 if len(request.URL.RawQuery) > 0 { 1160 request.URL.RawQuery = "&" + opQuery 1161 } else { 1162 request.URL.RawQuery = opQuery 1163 } 1164 1165 request.Method = "GET" 1166 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1167 if err != nil { 1168 return out, metadata, &smithy.SerializationError{Err: err} 1169 } 1170 1171 if err := awsRestjson1_serializeOpHttpBindingsGetProfileObjectTypeTemplateInput(input, restEncoder); err != nil { 1172 return out, metadata, &smithy.SerializationError{Err: err} 1173 } 1174 1175 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1176 return out, metadata, &smithy.SerializationError{Err: err} 1177 } 1178 in.Request = request 1179 1180 return next.HandleSerialize(ctx, in) 1181} 1182func awsRestjson1_serializeOpHttpBindingsGetProfileObjectTypeTemplateInput(v *GetProfileObjectTypeTemplateInput, encoder *httpbinding.Encoder) error { 1183 if v == nil { 1184 return fmt.Errorf("unsupported serialization of nil %T", v) 1185 } 1186 1187 if v.TemplateId == nil || len(*v.TemplateId) == 0 { 1188 return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")} 1189 } 1190 if v.TemplateId != nil { 1191 if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil { 1192 return err 1193 } 1194 } 1195 1196 return nil 1197} 1198 1199type awsRestjson1_serializeOpListAccountIntegrations struct { 1200} 1201 1202func (*awsRestjson1_serializeOpListAccountIntegrations) ID() string { 1203 return "OperationSerializer" 1204} 1205 1206func (m *awsRestjson1_serializeOpListAccountIntegrations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1207 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1208) { 1209 request, ok := in.Request.(*smithyhttp.Request) 1210 if !ok { 1211 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1212 } 1213 1214 input, ok := in.Parameters.(*ListAccountIntegrationsInput) 1215 _ = input 1216 if !ok { 1217 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1218 } 1219 1220 opPath, opQuery := httpbinding.SplitURI("/integrations") 1221 request.URL.Path = opPath 1222 if len(request.URL.RawQuery) > 0 { 1223 request.URL.RawQuery = "&" + opQuery 1224 } else { 1225 request.URL.RawQuery = opQuery 1226 } 1227 1228 request.Method = "POST" 1229 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1230 if err != nil { 1231 return out, metadata, &smithy.SerializationError{Err: err} 1232 } 1233 1234 if err := awsRestjson1_serializeOpHttpBindingsListAccountIntegrationsInput(input, restEncoder); err != nil { 1235 return out, metadata, &smithy.SerializationError{Err: err} 1236 } 1237 1238 restEncoder.SetHeader("Content-Type").String("application/json") 1239 1240 jsonEncoder := smithyjson.NewEncoder() 1241 if err := awsRestjson1_serializeOpDocumentListAccountIntegrationsInput(input, jsonEncoder.Value); err != nil { 1242 return out, metadata, &smithy.SerializationError{Err: err} 1243 } 1244 1245 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1246 return out, metadata, &smithy.SerializationError{Err: err} 1247 } 1248 1249 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1250 return out, metadata, &smithy.SerializationError{Err: err} 1251 } 1252 in.Request = request 1253 1254 return next.HandleSerialize(ctx, in) 1255} 1256func awsRestjson1_serializeOpHttpBindingsListAccountIntegrationsInput(v *ListAccountIntegrationsInput, encoder *httpbinding.Encoder) error { 1257 if v == nil { 1258 return fmt.Errorf("unsupported serialization of nil %T", v) 1259 } 1260 1261 if v.MaxResults != nil { 1262 encoder.SetQuery("max-results").Integer(*v.MaxResults) 1263 } 1264 1265 if v.NextToken != nil { 1266 encoder.SetQuery("next-token").String(*v.NextToken) 1267 } 1268 1269 return nil 1270} 1271 1272func awsRestjson1_serializeOpDocumentListAccountIntegrationsInput(v *ListAccountIntegrationsInput, value smithyjson.Value) error { 1273 object := value.Object() 1274 defer object.Close() 1275 1276 if v.Uri != nil { 1277 ok := object.Key("Uri") 1278 ok.String(*v.Uri) 1279 } 1280 1281 return nil 1282} 1283 1284type awsRestjson1_serializeOpListDomains struct { 1285} 1286 1287func (*awsRestjson1_serializeOpListDomains) ID() string { 1288 return "OperationSerializer" 1289} 1290 1291func (m *awsRestjson1_serializeOpListDomains) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1292 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1293) { 1294 request, ok := in.Request.(*smithyhttp.Request) 1295 if !ok { 1296 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1297 } 1298 1299 input, ok := in.Parameters.(*ListDomainsInput) 1300 _ = input 1301 if !ok { 1302 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1303 } 1304 1305 opPath, opQuery := httpbinding.SplitURI("/domains") 1306 request.URL.Path = opPath 1307 if len(request.URL.RawQuery) > 0 { 1308 request.URL.RawQuery = "&" + opQuery 1309 } else { 1310 request.URL.RawQuery = opQuery 1311 } 1312 1313 request.Method = "GET" 1314 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1315 if err != nil { 1316 return out, metadata, &smithy.SerializationError{Err: err} 1317 } 1318 1319 if err := awsRestjson1_serializeOpHttpBindingsListDomainsInput(input, restEncoder); err != nil { 1320 return out, metadata, &smithy.SerializationError{Err: err} 1321 } 1322 1323 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1324 return out, metadata, &smithy.SerializationError{Err: err} 1325 } 1326 in.Request = request 1327 1328 return next.HandleSerialize(ctx, in) 1329} 1330func awsRestjson1_serializeOpHttpBindingsListDomainsInput(v *ListDomainsInput, encoder *httpbinding.Encoder) error { 1331 if v == nil { 1332 return fmt.Errorf("unsupported serialization of nil %T", v) 1333 } 1334 1335 if v.MaxResults != nil { 1336 encoder.SetQuery("max-results").Integer(*v.MaxResults) 1337 } 1338 1339 if v.NextToken != nil { 1340 encoder.SetQuery("next-token").String(*v.NextToken) 1341 } 1342 1343 return nil 1344} 1345 1346type awsRestjson1_serializeOpListIntegrations struct { 1347} 1348 1349func (*awsRestjson1_serializeOpListIntegrations) ID() string { 1350 return "OperationSerializer" 1351} 1352 1353func (m *awsRestjson1_serializeOpListIntegrations) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1354 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1355) { 1356 request, ok := in.Request.(*smithyhttp.Request) 1357 if !ok { 1358 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1359 } 1360 1361 input, ok := in.Parameters.(*ListIntegrationsInput) 1362 _ = input 1363 if !ok { 1364 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1365 } 1366 1367 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/integrations") 1368 request.URL.Path = opPath 1369 if len(request.URL.RawQuery) > 0 { 1370 request.URL.RawQuery = "&" + opQuery 1371 } else { 1372 request.URL.RawQuery = opQuery 1373 } 1374 1375 request.Method = "GET" 1376 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1377 if err != nil { 1378 return out, metadata, &smithy.SerializationError{Err: err} 1379 } 1380 1381 if err := awsRestjson1_serializeOpHttpBindingsListIntegrationsInput(input, restEncoder); err != nil { 1382 return out, metadata, &smithy.SerializationError{Err: err} 1383 } 1384 1385 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1386 return out, metadata, &smithy.SerializationError{Err: err} 1387 } 1388 in.Request = request 1389 1390 return next.HandleSerialize(ctx, in) 1391} 1392func awsRestjson1_serializeOpHttpBindingsListIntegrationsInput(v *ListIntegrationsInput, encoder *httpbinding.Encoder) error { 1393 if v == nil { 1394 return fmt.Errorf("unsupported serialization of nil %T", v) 1395 } 1396 1397 if v.DomainName == nil || len(*v.DomainName) == 0 { 1398 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 1399 } 1400 if v.DomainName != nil { 1401 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 1402 return err 1403 } 1404 } 1405 1406 if v.MaxResults != nil { 1407 encoder.SetQuery("max-results").Integer(*v.MaxResults) 1408 } 1409 1410 if v.NextToken != nil { 1411 encoder.SetQuery("next-token").String(*v.NextToken) 1412 } 1413 1414 return nil 1415} 1416 1417type awsRestjson1_serializeOpListProfileObjects struct { 1418} 1419 1420func (*awsRestjson1_serializeOpListProfileObjects) ID() string { 1421 return "OperationSerializer" 1422} 1423 1424func (m *awsRestjson1_serializeOpListProfileObjects) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1425 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1426) { 1427 request, ok := in.Request.(*smithyhttp.Request) 1428 if !ok { 1429 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1430 } 1431 1432 input, ok := in.Parameters.(*ListProfileObjectsInput) 1433 _ = input 1434 if !ok { 1435 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1436 } 1437 1438 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/profiles/objects") 1439 request.URL.Path = opPath 1440 if len(request.URL.RawQuery) > 0 { 1441 request.URL.RawQuery = "&" + opQuery 1442 } else { 1443 request.URL.RawQuery = opQuery 1444 } 1445 1446 request.Method = "POST" 1447 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1448 if err != nil { 1449 return out, metadata, &smithy.SerializationError{Err: err} 1450 } 1451 1452 if err := awsRestjson1_serializeOpHttpBindingsListProfileObjectsInput(input, restEncoder); err != nil { 1453 return out, metadata, &smithy.SerializationError{Err: err} 1454 } 1455 1456 restEncoder.SetHeader("Content-Type").String("application/json") 1457 1458 jsonEncoder := smithyjson.NewEncoder() 1459 if err := awsRestjson1_serializeOpDocumentListProfileObjectsInput(input, jsonEncoder.Value); err != nil { 1460 return out, metadata, &smithy.SerializationError{Err: err} 1461 } 1462 1463 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1464 return out, metadata, &smithy.SerializationError{Err: err} 1465 } 1466 1467 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1468 return out, metadata, &smithy.SerializationError{Err: err} 1469 } 1470 in.Request = request 1471 1472 return next.HandleSerialize(ctx, in) 1473} 1474func awsRestjson1_serializeOpHttpBindingsListProfileObjectsInput(v *ListProfileObjectsInput, encoder *httpbinding.Encoder) error { 1475 if v == nil { 1476 return fmt.Errorf("unsupported serialization of nil %T", v) 1477 } 1478 1479 if v.DomainName == nil || len(*v.DomainName) == 0 { 1480 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 1481 } 1482 if v.DomainName != nil { 1483 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 1484 return err 1485 } 1486 } 1487 1488 if v.MaxResults != nil { 1489 encoder.SetQuery("max-results").Integer(*v.MaxResults) 1490 } 1491 1492 if v.NextToken != nil { 1493 encoder.SetQuery("next-token").String(*v.NextToken) 1494 } 1495 1496 return nil 1497} 1498 1499func awsRestjson1_serializeOpDocumentListProfileObjectsInput(v *ListProfileObjectsInput, value smithyjson.Value) error { 1500 object := value.Object() 1501 defer object.Close() 1502 1503 if v.ObjectTypeName != nil { 1504 ok := object.Key("ObjectTypeName") 1505 ok.String(*v.ObjectTypeName) 1506 } 1507 1508 if v.ProfileId != nil { 1509 ok := object.Key("ProfileId") 1510 ok.String(*v.ProfileId) 1511 } 1512 1513 return nil 1514} 1515 1516type awsRestjson1_serializeOpListProfileObjectTypes struct { 1517} 1518 1519func (*awsRestjson1_serializeOpListProfileObjectTypes) ID() string { 1520 return "OperationSerializer" 1521} 1522 1523func (m *awsRestjson1_serializeOpListProfileObjectTypes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1524 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1525) { 1526 request, ok := in.Request.(*smithyhttp.Request) 1527 if !ok { 1528 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1529 } 1530 1531 input, ok := in.Parameters.(*ListProfileObjectTypesInput) 1532 _ = input 1533 if !ok { 1534 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1535 } 1536 1537 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/object-types") 1538 request.URL.Path = opPath 1539 if len(request.URL.RawQuery) > 0 { 1540 request.URL.RawQuery = "&" + opQuery 1541 } else { 1542 request.URL.RawQuery = opQuery 1543 } 1544 1545 request.Method = "GET" 1546 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1547 if err != nil { 1548 return out, metadata, &smithy.SerializationError{Err: err} 1549 } 1550 1551 if err := awsRestjson1_serializeOpHttpBindingsListProfileObjectTypesInput(input, restEncoder); err != nil { 1552 return out, metadata, &smithy.SerializationError{Err: err} 1553 } 1554 1555 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1556 return out, metadata, &smithy.SerializationError{Err: err} 1557 } 1558 in.Request = request 1559 1560 return next.HandleSerialize(ctx, in) 1561} 1562func awsRestjson1_serializeOpHttpBindingsListProfileObjectTypesInput(v *ListProfileObjectTypesInput, encoder *httpbinding.Encoder) error { 1563 if v == nil { 1564 return fmt.Errorf("unsupported serialization of nil %T", v) 1565 } 1566 1567 if v.DomainName == nil || len(*v.DomainName) == 0 { 1568 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 1569 } 1570 if v.DomainName != nil { 1571 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 1572 return err 1573 } 1574 } 1575 1576 if v.MaxResults != nil { 1577 encoder.SetQuery("max-results").Integer(*v.MaxResults) 1578 } 1579 1580 if v.NextToken != nil { 1581 encoder.SetQuery("next-token").String(*v.NextToken) 1582 } 1583 1584 return nil 1585} 1586 1587type awsRestjson1_serializeOpListProfileObjectTypeTemplates struct { 1588} 1589 1590func (*awsRestjson1_serializeOpListProfileObjectTypeTemplates) ID() string { 1591 return "OperationSerializer" 1592} 1593 1594func (m *awsRestjson1_serializeOpListProfileObjectTypeTemplates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1595 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1596) { 1597 request, ok := in.Request.(*smithyhttp.Request) 1598 if !ok { 1599 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1600 } 1601 1602 input, ok := in.Parameters.(*ListProfileObjectTypeTemplatesInput) 1603 _ = input 1604 if !ok { 1605 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1606 } 1607 1608 opPath, opQuery := httpbinding.SplitURI("/templates") 1609 request.URL.Path = opPath 1610 if len(request.URL.RawQuery) > 0 { 1611 request.URL.RawQuery = "&" + opQuery 1612 } else { 1613 request.URL.RawQuery = opQuery 1614 } 1615 1616 request.Method = "GET" 1617 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1618 if err != nil { 1619 return out, metadata, &smithy.SerializationError{Err: err} 1620 } 1621 1622 if err := awsRestjson1_serializeOpHttpBindingsListProfileObjectTypeTemplatesInput(input, restEncoder); err != nil { 1623 return out, metadata, &smithy.SerializationError{Err: err} 1624 } 1625 1626 if request.Request, err = restEncoder.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} 1633func awsRestjson1_serializeOpHttpBindingsListProfileObjectTypeTemplatesInput(v *ListProfileObjectTypeTemplatesInput, encoder *httpbinding.Encoder) error { 1634 if v == nil { 1635 return fmt.Errorf("unsupported serialization of nil %T", v) 1636 } 1637 1638 if v.MaxResults != nil { 1639 encoder.SetQuery("max-results").Integer(*v.MaxResults) 1640 } 1641 1642 if v.NextToken != nil { 1643 encoder.SetQuery("next-token").String(*v.NextToken) 1644 } 1645 1646 return nil 1647} 1648 1649type awsRestjson1_serializeOpListTagsForResource struct { 1650} 1651 1652func (*awsRestjson1_serializeOpListTagsForResource) ID() string { 1653 return "OperationSerializer" 1654} 1655 1656func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1657 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1658) { 1659 request, ok := in.Request.(*smithyhttp.Request) 1660 if !ok { 1661 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1662 } 1663 1664 input, ok := in.Parameters.(*ListTagsForResourceInput) 1665 _ = input 1666 if !ok { 1667 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1668 } 1669 1670 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 1671 request.URL.Path = opPath 1672 if len(request.URL.RawQuery) > 0 { 1673 request.URL.RawQuery = "&" + opQuery 1674 } else { 1675 request.URL.RawQuery = opQuery 1676 } 1677 1678 request.Method = "GET" 1679 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1680 if err != nil { 1681 return out, metadata, &smithy.SerializationError{Err: err} 1682 } 1683 1684 if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil { 1685 return out, metadata, &smithy.SerializationError{Err: err} 1686 } 1687 1688 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1689 return out, metadata, &smithy.SerializationError{Err: err} 1690 } 1691 in.Request = request 1692 1693 return next.HandleSerialize(ctx, in) 1694} 1695func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error { 1696 if v == nil { 1697 return fmt.Errorf("unsupported serialization of nil %T", v) 1698 } 1699 1700 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 1701 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 1702 } 1703 if v.ResourceArn != nil { 1704 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 1705 return err 1706 } 1707 } 1708 1709 return nil 1710} 1711 1712type awsRestjson1_serializeOpPutIntegration struct { 1713} 1714 1715func (*awsRestjson1_serializeOpPutIntegration) ID() string { 1716 return "OperationSerializer" 1717} 1718 1719func (m *awsRestjson1_serializeOpPutIntegration) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1720 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1721) { 1722 request, ok := in.Request.(*smithyhttp.Request) 1723 if !ok { 1724 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1725 } 1726 1727 input, ok := in.Parameters.(*PutIntegrationInput) 1728 _ = input 1729 if !ok { 1730 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1731 } 1732 1733 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/integrations") 1734 request.URL.Path = opPath 1735 if len(request.URL.RawQuery) > 0 { 1736 request.URL.RawQuery = "&" + opQuery 1737 } else { 1738 request.URL.RawQuery = opQuery 1739 } 1740 1741 request.Method = "PUT" 1742 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1743 if err != nil { 1744 return out, metadata, &smithy.SerializationError{Err: err} 1745 } 1746 1747 if err := awsRestjson1_serializeOpHttpBindingsPutIntegrationInput(input, restEncoder); err != nil { 1748 return out, metadata, &smithy.SerializationError{Err: err} 1749 } 1750 1751 restEncoder.SetHeader("Content-Type").String("application/json") 1752 1753 jsonEncoder := smithyjson.NewEncoder() 1754 if err := awsRestjson1_serializeOpDocumentPutIntegrationInput(input, jsonEncoder.Value); err != nil { 1755 return out, metadata, &smithy.SerializationError{Err: err} 1756 } 1757 1758 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1759 return out, metadata, &smithy.SerializationError{Err: err} 1760 } 1761 1762 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1763 return out, metadata, &smithy.SerializationError{Err: err} 1764 } 1765 in.Request = request 1766 1767 return next.HandleSerialize(ctx, in) 1768} 1769func awsRestjson1_serializeOpHttpBindingsPutIntegrationInput(v *PutIntegrationInput, encoder *httpbinding.Encoder) error { 1770 if v == nil { 1771 return fmt.Errorf("unsupported serialization of nil %T", v) 1772 } 1773 1774 if v.DomainName == nil || len(*v.DomainName) == 0 { 1775 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 1776 } 1777 if v.DomainName != nil { 1778 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 1779 return err 1780 } 1781 } 1782 1783 return nil 1784} 1785 1786func awsRestjson1_serializeOpDocumentPutIntegrationInput(v *PutIntegrationInput, value smithyjson.Value) error { 1787 object := value.Object() 1788 defer object.Close() 1789 1790 if v.ObjectTypeName != nil { 1791 ok := object.Key("ObjectTypeName") 1792 ok.String(*v.ObjectTypeName) 1793 } 1794 1795 if v.Tags != nil { 1796 ok := object.Key("Tags") 1797 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 1798 return err 1799 } 1800 } 1801 1802 if v.Uri != nil { 1803 ok := object.Key("Uri") 1804 ok.String(*v.Uri) 1805 } 1806 1807 return nil 1808} 1809 1810type awsRestjson1_serializeOpPutProfileObject struct { 1811} 1812 1813func (*awsRestjson1_serializeOpPutProfileObject) ID() string { 1814 return "OperationSerializer" 1815} 1816 1817func (m *awsRestjson1_serializeOpPutProfileObject) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1818 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1819) { 1820 request, ok := in.Request.(*smithyhttp.Request) 1821 if !ok { 1822 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1823 } 1824 1825 input, ok := in.Parameters.(*PutProfileObjectInput) 1826 _ = input 1827 if !ok { 1828 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1829 } 1830 1831 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/profiles/objects") 1832 request.URL.Path = opPath 1833 if len(request.URL.RawQuery) > 0 { 1834 request.URL.RawQuery = "&" + opQuery 1835 } else { 1836 request.URL.RawQuery = opQuery 1837 } 1838 1839 request.Method = "PUT" 1840 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1841 if err != nil { 1842 return out, metadata, &smithy.SerializationError{Err: err} 1843 } 1844 1845 if err := awsRestjson1_serializeOpHttpBindingsPutProfileObjectInput(input, restEncoder); err != nil { 1846 return out, metadata, &smithy.SerializationError{Err: err} 1847 } 1848 1849 restEncoder.SetHeader("Content-Type").String("application/json") 1850 1851 jsonEncoder := smithyjson.NewEncoder() 1852 if err := awsRestjson1_serializeOpDocumentPutProfileObjectInput(input, jsonEncoder.Value); err != nil { 1853 return out, metadata, &smithy.SerializationError{Err: err} 1854 } 1855 1856 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1857 return out, metadata, &smithy.SerializationError{Err: err} 1858 } 1859 1860 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1861 return out, metadata, &smithy.SerializationError{Err: err} 1862 } 1863 in.Request = request 1864 1865 return next.HandleSerialize(ctx, in) 1866} 1867func awsRestjson1_serializeOpHttpBindingsPutProfileObjectInput(v *PutProfileObjectInput, encoder *httpbinding.Encoder) error { 1868 if v == nil { 1869 return fmt.Errorf("unsupported serialization of nil %T", v) 1870 } 1871 1872 if v.DomainName == nil || len(*v.DomainName) == 0 { 1873 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 1874 } 1875 if v.DomainName != nil { 1876 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 1877 return err 1878 } 1879 } 1880 1881 return nil 1882} 1883 1884func awsRestjson1_serializeOpDocumentPutProfileObjectInput(v *PutProfileObjectInput, value smithyjson.Value) error { 1885 object := value.Object() 1886 defer object.Close() 1887 1888 if v.Object != nil { 1889 ok := object.Key("Object") 1890 ok.String(*v.Object) 1891 } 1892 1893 if v.ObjectTypeName != nil { 1894 ok := object.Key("ObjectTypeName") 1895 ok.String(*v.ObjectTypeName) 1896 } 1897 1898 return nil 1899} 1900 1901type awsRestjson1_serializeOpPutProfileObjectType struct { 1902} 1903 1904func (*awsRestjson1_serializeOpPutProfileObjectType) ID() string { 1905 return "OperationSerializer" 1906} 1907 1908func (m *awsRestjson1_serializeOpPutProfileObjectType) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 1909 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 1910) { 1911 request, ok := in.Request.(*smithyhttp.Request) 1912 if !ok { 1913 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 1914 } 1915 1916 input, ok := in.Parameters.(*PutProfileObjectTypeInput) 1917 _ = input 1918 if !ok { 1919 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 1920 } 1921 1922 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/object-types/{ObjectTypeName}") 1923 request.URL.Path = opPath 1924 if len(request.URL.RawQuery) > 0 { 1925 request.URL.RawQuery = "&" + opQuery 1926 } else { 1927 request.URL.RawQuery = opQuery 1928 } 1929 1930 request.Method = "PUT" 1931 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 1932 if err != nil { 1933 return out, metadata, &smithy.SerializationError{Err: err} 1934 } 1935 1936 if err := awsRestjson1_serializeOpHttpBindingsPutProfileObjectTypeInput(input, restEncoder); err != nil { 1937 return out, metadata, &smithy.SerializationError{Err: err} 1938 } 1939 1940 restEncoder.SetHeader("Content-Type").String("application/json") 1941 1942 jsonEncoder := smithyjson.NewEncoder() 1943 if err := awsRestjson1_serializeOpDocumentPutProfileObjectTypeInput(input, jsonEncoder.Value); err != nil { 1944 return out, metadata, &smithy.SerializationError{Err: err} 1945 } 1946 1947 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 1948 return out, metadata, &smithy.SerializationError{Err: err} 1949 } 1950 1951 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 1952 return out, metadata, &smithy.SerializationError{Err: err} 1953 } 1954 in.Request = request 1955 1956 return next.HandleSerialize(ctx, in) 1957} 1958func awsRestjson1_serializeOpHttpBindingsPutProfileObjectTypeInput(v *PutProfileObjectTypeInput, encoder *httpbinding.Encoder) error { 1959 if v == nil { 1960 return fmt.Errorf("unsupported serialization of nil %T", v) 1961 } 1962 1963 if v.DomainName == nil || len(*v.DomainName) == 0 { 1964 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 1965 } 1966 if v.DomainName != nil { 1967 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 1968 return err 1969 } 1970 } 1971 1972 if v.ObjectTypeName == nil || len(*v.ObjectTypeName) == 0 { 1973 return &smithy.SerializationError{Err: fmt.Errorf("input member ObjectTypeName must not be empty")} 1974 } 1975 if v.ObjectTypeName != nil { 1976 if err := encoder.SetURI("ObjectTypeName").String(*v.ObjectTypeName); err != nil { 1977 return err 1978 } 1979 } 1980 1981 return nil 1982} 1983 1984func awsRestjson1_serializeOpDocumentPutProfileObjectTypeInput(v *PutProfileObjectTypeInput, value smithyjson.Value) error { 1985 object := value.Object() 1986 defer object.Close() 1987 1988 if v.AllowProfileCreation { 1989 ok := object.Key("AllowProfileCreation") 1990 ok.Boolean(v.AllowProfileCreation) 1991 } 1992 1993 if v.Description != nil { 1994 ok := object.Key("Description") 1995 ok.String(*v.Description) 1996 } 1997 1998 if v.EncryptionKey != nil { 1999 ok := object.Key("EncryptionKey") 2000 ok.String(*v.EncryptionKey) 2001 } 2002 2003 if v.ExpirationDays != nil { 2004 ok := object.Key("ExpirationDays") 2005 ok.Integer(*v.ExpirationDays) 2006 } 2007 2008 if v.Fields != nil { 2009 ok := object.Key("Fields") 2010 if err := awsRestjson1_serializeDocumentFieldMap(v.Fields, ok); err != nil { 2011 return err 2012 } 2013 } 2014 2015 if v.Keys != nil { 2016 ok := object.Key("Keys") 2017 if err := awsRestjson1_serializeDocumentKeyMap(v.Keys, ok); err != nil { 2018 return err 2019 } 2020 } 2021 2022 if v.Tags != nil { 2023 ok := object.Key("Tags") 2024 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 2025 return err 2026 } 2027 } 2028 2029 if v.TemplateId != nil { 2030 ok := object.Key("TemplateId") 2031 ok.String(*v.TemplateId) 2032 } 2033 2034 return nil 2035} 2036 2037type awsRestjson1_serializeOpSearchProfiles struct { 2038} 2039 2040func (*awsRestjson1_serializeOpSearchProfiles) ID() string { 2041 return "OperationSerializer" 2042} 2043 2044func (m *awsRestjson1_serializeOpSearchProfiles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2045 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2046) { 2047 request, ok := in.Request.(*smithyhttp.Request) 2048 if !ok { 2049 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2050 } 2051 2052 input, ok := in.Parameters.(*SearchProfilesInput) 2053 _ = input 2054 if !ok { 2055 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2056 } 2057 2058 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/profiles/search") 2059 request.URL.Path = opPath 2060 if len(request.URL.RawQuery) > 0 { 2061 request.URL.RawQuery = "&" + opQuery 2062 } else { 2063 request.URL.RawQuery = opQuery 2064 } 2065 2066 request.Method = "POST" 2067 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2068 if err != nil { 2069 return out, metadata, &smithy.SerializationError{Err: err} 2070 } 2071 2072 if err := awsRestjson1_serializeOpHttpBindingsSearchProfilesInput(input, restEncoder); err != nil { 2073 return out, metadata, &smithy.SerializationError{Err: err} 2074 } 2075 2076 restEncoder.SetHeader("Content-Type").String("application/json") 2077 2078 jsonEncoder := smithyjson.NewEncoder() 2079 if err := awsRestjson1_serializeOpDocumentSearchProfilesInput(input, jsonEncoder.Value); err != nil { 2080 return out, metadata, &smithy.SerializationError{Err: err} 2081 } 2082 2083 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2084 return out, metadata, &smithy.SerializationError{Err: err} 2085 } 2086 2087 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2088 return out, metadata, &smithy.SerializationError{Err: err} 2089 } 2090 in.Request = request 2091 2092 return next.HandleSerialize(ctx, in) 2093} 2094func awsRestjson1_serializeOpHttpBindingsSearchProfilesInput(v *SearchProfilesInput, encoder *httpbinding.Encoder) error { 2095 if v == nil { 2096 return fmt.Errorf("unsupported serialization of nil %T", v) 2097 } 2098 2099 if v.DomainName == nil || len(*v.DomainName) == 0 { 2100 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 2101 } 2102 if v.DomainName != nil { 2103 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 2104 return err 2105 } 2106 } 2107 2108 if v.MaxResults != nil { 2109 encoder.SetQuery("max-results").Integer(*v.MaxResults) 2110 } 2111 2112 if v.NextToken != nil { 2113 encoder.SetQuery("next-token").String(*v.NextToken) 2114 } 2115 2116 return nil 2117} 2118 2119func awsRestjson1_serializeOpDocumentSearchProfilesInput(v *SearchProfilesInput, value smithyjson.Value) error { 2120 object := value.Object() 2121 defer object.Close() 2122 2123 if v.KeyName != nil { 2124 ok := object.Key("KeyName") 2125 ok.String(*v.KeyName) 2126 } 2127 2128 if v.Values != nil { 2129 ok := object.Key("Values") 2130 if err := awsRestjson1_serializeDocumentRequestValueList(v.Values, ok); err != nil { 2131 return err 2132 } 2133 } 2134 2135 return nil 2136} 2137 2138type awsRestjson1_serializeOpTagResource struct { 2139} 2140 2141func (*awsRestjson1_serializeOpTagResource) ID() string { 2142 return "OperationSerializer" 2143} 2144 2145func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2146 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2147) { 2148 request, ok := in.Request.(*smithyhttp.Request) 2149 if !ok { 2150 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2151 } 2152 2153 input, ok := in.Parameters.(*TagResourceInput) 2154 _ = input 2155 if !ok { 2156 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2157 } 2158 2159 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 2160 request.URL.Path = opPath 2161 if len(request.URL.RawQuery) > 0 { 2162 request.URL.RawQuery = "&" + opQuery 2163 } else { 2164 request.URL.RawQuery = opQuery 2165 } 2166 2167 request.Method = "POST" 2168 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2169 if err != nil { 2170 return out, metadata, &smithy.SerializationError{Err: err} 2171 } 2172 2173 if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil { 2174 return out, metadata, &smithy.SerializationError{Err: err} 2175 } 2176 2177 restEncoder.SetHeader("Content-Type").String("application/json") 2178 2179 jsonEncoder := smithyjson.NewEncoder() 2180 if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil { 2181 return out, metadata, &smithy.SerializationError{Err: err} 2182 } 2183 2184 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2185 return out, metadata, &smithy.SerializationError{Err: err} 2186 } 2187 2188 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2189 return out, metadata, &smithy.SerializationError{Err: err} 2190 } 2191 in.Request = request 2192 2193 return next.HandleSerialize(ctx, in) 2194} 2195func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error { 2196 if v == nil { 2197 return fmt.Errorf("unsupported serialization of nil %T", v) 2198 } 2199 2200 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 2201 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 2202 } 2203 if v.ResourceArn != nil { 2204 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 2205 return err 2206 } 2207 } 2208 2209 return nil 2210} 2211 2212func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error { 2213 object := value.Object() 2214 defer object.Close() 2215 2216 if v.Tags != nil { 2217 ok := object.Key("tags") 2218 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 2219 return err 2220 } 2221 } 2222 2223 return nil 2224} 2225 2226type awsRestjson1_serializeOpUntagResource struct { 2227} 2228 2229func (*awsRestjson1_serializeOpUntagResource) ID() string { 2230 return "OperationSerializer" 2231} 2232 2233func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2234 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2235) { 2236 request, ok := in.Request.(*smithyhttp.Request) 2237 if !ok { 2238 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2239 } 2240 2241 input, ok := in.Parameters.(*UntagResourceInput) 2242 _ = input 2243 if !ok { 2244 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2245 } 2246 2247 opPath, opQuery := httpbinding.SplitURI("/tags/{resourceArn}") 2248 request.URL.Path = opPath 2249 if len(request.URL.RawQuery) > 0 { 2250 request.URL.RawQuery = "&" + opQuery 2251 } else { 2252 request.URL.RawQuery = opQuery 2253 } 2254 2255 request.Method = "DELETE" 2256 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2257 if err != nil { 2258 return out, metadata, &smithy.SerializationError{Err: err} 2259 } 2260 2261 if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil { 2262 return out, metadata, &smithy.SerializationError{Err: err} 2263 } 2264 2265 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2266 return out, metadata, &smithy.SerializationError{Err: err} 2267 } 2268 in.Request = request 2269 2270 return next.HandleSerialize(ctx, in) 2271} 2272func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error { 2273 if v == nil { 2274 return fmt.Errorf("unsupported serialization of nil %T", v) 2275 } 2276 2277 if v.ResourceArn == nil || len(*v.ResourceArn) == 0 { 2278 return &smithy.SerializationError{Err: fmt.Errorf("input member resourceArn must not be empty")} 2279 } 2280 if v.ResourceArn != nil { 2281 if err := encoder.SetURI("resourceArn").String(*v.ResourceArn); err != nil { 2282 return err 2283 } 2284 } 2285 2286 if v.TagKeys != nil { 2287 for i := range v.TagKeys { 2288 encoder.AddQuery("tagKeys").String(v.TagKeys[i]) 2289 } 2290 } 2291 2292 return nil 2293} 2294 2295type awsRestjson1_serializeOpUpdateDomain struct { 2296} 2297 2298func (*awsRestjson1_serializeOpUpdateDomain) ID() string { 2299 return "OperationSerializer" 2300} 2301 2302func (m *awsRestjson1_serializeOpUpdateDomain) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2303 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2304) { 2305 request, ok := in.Request.(*smithyhttp.Request) 2306 if !ok { 2307 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2308 } 2309 2310 input, ok := in.Parameters.(*UpdateDomainInput) 2311 _ = input 2312 if !ok { 2313 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2314 } 2315 2316 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}") 2317 request.URL.Path = opPath 2318 if len(request.URL.RawQuery) > 0 { 2319 request.URL.RawQuery = "&" + opQuery 2320 } else { 2321 request.URL.RawQuery = opQuery 2322 } 2323 2324 request.Method = "PUT" 2325 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2326 if err != nil { 2327 return out, metadata, &smithy.SerializationError{Err: err} 2328 } 2329 2330 if err := awsRestjson1_serializeOpHttpBindingsUpdateDomainInput(input, restEncoder); err != nil { 2331 return out, metadata, &smithy.SerializationError{Err: err} 2332 } 2333 2334 restEncoder.SetHeader("Content-Type").String("application/json") 2335 2336 jsonEncoder := smithyjson.NewEncoder() 2337 if err := awsRestjson1_serializeOpDocumentUpdateDomainInput(input, jsonEncoder.Value); err != nil { 2338 return out, metadata, &smithy.SerializationError{Err: err} 2339 } 2340 2341 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2342 return out, metadata, &smithy.SerializationError{Err: err} 2343 } 2344 2345 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2346 return out, metadata, &smithy.SerializationError{Err: err} 2347 } 2348 in.Request = request 2349 2350 return next.HandleSerialize(ctx, in) 2351} 2352func awsRestjson1_serializeOpHttpBindingsUpdateDomainInput(v *UpdateDomainInput, encoder *httpbinding.Encoder) error { 2353 if v == nil { 2354 return fmt.Errorf("unsupported serialization of nil %T", v) 2355 } 2356 2357 if v.DomainName == nil || len(*v.DomainName) == 0 { 2358 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 2359 } 2360 if v.DomainName != nil { 2361 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 2362 return err 2363 } 2364 } 2365 2366 return nil 2367} 2368 2369func awsRestjson1_serializeOpDocumentUpdateDomainInput(v *UpdateDomainInput, value smithyjson.Value) error { 2370 object := value.Object() 2371 defer object.Close() 2372 2373 if v.DeadLetterQueueUrl != nil { 2374 ok := object.Key("DeadLetterQueueUrl") 2375 ok.String(*v.DeadLetterQueueUrl) 2376 } 2377 2378 if v.DefaultEncryptionKey != nil { 2379 ok := object.Key("DefaultEncryptionKey") 2380 ok.String(*v.DefaultEncryptionKey) 2381 } 2382 2383 if v.DefaultExpirationDays != nil { 2384 ok := object.Key("DefaultExpirationDays") 2385 ok.Integer(*v.DefaultExpirationDays) 2386 } 2387 2388 if v.Tags != nil { 2389 ok := object.Key("Tags") 2390 if err := awsRestjson1_serializeDocumentTagMap(v.Tags, ok); err != nil { 2391 return err 2392 } 2393 } 2394 2395 return nil 2396} 2397 2398type awsRestjson1_serializeOpUpdateProfile struct { 2399} 2400 2401func (*awsRestjson1_serializeOpUpdateProfile) ID() string { 2402 return "OperationSerializer" 2403} 2404 2405func (m *awsRestjson1_serializeOpUpdateProfile) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) ( 2406 out middleware.SerializeOutput, metadata middleware.Metadata, err error, 2407) { 2408 request, ok := in.Request.(*smithyhttp.Request) 2409 if !ok { 2410 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)} 2411 } 2412 2413 input, ok := in.Parameters.(*UpdateProfileInput) 2414 _ = input 2415 if !ok { 2416 return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)} 2417 } 2418 2419 opPath, opQuery := httpbinding.SplitURI("/domains/{DomainName}/profiles") 2420 request.URL.Path = opPath 2421 if len(request.URL.RawQuery) > 0 { 2422 request.URL.RawQuery = "&" + opQuery 2423 } else { 2424 request.URL.RawQuery = opQuery 2425 } 2426 2427 request.Method = "PUT" 2428 restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header) 2429 if err != nil { 2430 return out, metadata, &smithy.SerializationError{Err: err} 2431 } 2432 2433 if err := awsRestjson1_serializeOpHttpBindingsUpdateProfileInput(input, restEncoder); err != nil { 2434 return out, metadata, &smithy.SerializationError{Err: err} 2435 } 2436 2437 restEncoder.SetHeader("Content-Type").String("application/json") 2438 2439 jsonEncoder := smithyjson.NewEncoder() 2440 if err := awsRestjson1_serializeOpDocumentUpdateProfileInput(input, jsonEncoder.Value); err != nil { 2441 return out, metadata, &smithy.SerializationError{Err: err} 2442 } 2443 2444 if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil { 2445 return out, metadata, &smithy.SerializationError{Err: err} 2446 } 2447 2448 if request.Request, err = restEncoder.Encode(request.Request); err != nil { 2449 return out, metadata, &smithy.SerializationError{Err: err} 2450 } 2451 in.Request = request 2452 2453 return next.HandleSerialize(ctx, in) 2454} 2455func awsRestjson1_serializeOpHttpBindingsUpdateProfileInput(v *UpdateProfileInput, encoder *httpbinding.Encoder) error { 2456 if v == nil { 2457 return fmt.Errorf("unsupported serialization of nil %T", v) 2458 } 2459 2460 if v.DomainName == nil || len(*v.DomainName) == 0 { 2461 return &smithy.SerializationError{Err: fmt.Errorf("input member DomainName must not be empty")} 2462 } 2463 if v.DomainName != nil { 2464 if err := encoder.SetURI("DomainName").String(*v.DomainName); err != nil { 2465 return err 2466 } 2467 } 2468 2469 return nil 2470} 2471 2472func awsRestjson1_serializeOpDocumentUpdateProfileInput(v *UpdateProfileInput, value smithyjson.Value) error { 2473 object := value.Object() 2474 defer object.Close() 2475 2476 if v.AccountNumber != nil { 2477 ok := object.Key("AccountNumber") 2478 ok.String(*v.AccountNumber) 2479 } 2480 2481 if v.AdditionalInformation != nil { 2482 ok := object.Key("AdditionalInformation") 2483 ok.String(*v.AdditionalInformation) 2484 } 2485 2486 if v.Address != nil { 2487 ok := object.Key("Address") 2488 if err := awsRestjson1_serializeDocumentUpdateAddress(v.Address, ok); err != nil { 2489 return err 2490 } 2491 } 2492 2493 if v.Attributes != nil { 2494 ok := object.Key("Attributes") 2495 if err := awsRestjson1_serializeDocumentUpdateAttributes(v.Attributes, ok); err != nil { 2496 return err 2497 } 2498 } 2499 2500 if v.BillingAddress != nil { 2501 ok := object.Key("BillingAddress") 2502 if err := awsRestjson1_serializeDocumentUpdateAddress(v.BillingAddress, ok); err != nil { 2503 return err 2504 } 2505 } 2506 2507 if v.BirthDate != nil { 2508 ok := object.Key("BirthDate") 2509 ok.String(*v.BirthDate) 2510 } 2511 2512 if v.BusinessEmailAddress != nil { 2513 ok := object.Key("BusinessEmailAddress") 2514 ok.String(*v.BusinessEmailAddress) 2515 } 2516 2517 if v.BusinessName != nil { 2518 ok := object.Key("BusinessName") 2519 ok.String(*v.BusinessName) 2520 } 2521 2522 if v.BusinessPhoneNumber != nil { 2523 ok := object.Key("BusinessPhoneNumber") 2524 ok.String(*v.BusinessPhoneNumber) 2525 } 2526 2527 if v.EmailAddress != nil { 2528 ok := object.Key("EmailAddress") 2529 ok.String(*v.EmailAddress) 2530 } 2531 2532 if v.FirstName != nil { 2533 ok := object.Key("FirstName") 2534 ok.String(*v.FirstName) 2535 } 2536 2537 if len(v.Gender) > 0 { 2538 ok := object.Key("Gender") 2539 ok.String(string(v.Gender)) 2540 } 2541 2542 if v.HomePhoneNumber != nil { 2543 ok := object.Key("HomePhoneNumber") 2544 ok.String(*v.HomePhoneNumber) 2545 } 2546 2547 if v.LastName != nil { 2548 ok := object.Key("LastName") 2549 ok.String(*v.LastName) 2550 } 2551 2552 if v.MailingAddress != nil { 2553 ok := object.Key("MailingAddress") 2554 if err := awsRestjson1_serializeDocumentUpdateAddress(v.MailingAddress, ok); err != nil { 2555 return err 2556 } 2557 } 2558 2559 if v.MiddleName != nil { 2560 ok := object.Key("MiddleName") 2561 ok.String(*v.MiddleName) 2562 } 2563 2564 if v.MobilePhoneNumber != nil { 2565 ok := object.Key("MobilePhoneNumber") 2566 ok.String(*v.MobilePhoneNumber) 2567 } 2568 2569 if len(v.PartyType) > 0 { 2570 ok := object.Key("PartyType") 2571 ok.String(string(v.PartyType)) 2572 } 2573 2574 if v.PersonalEmailAddress != nil { 2575 ok := object.Key("PersonalEmailAddress") 2576 ok.String(*v.PersonalEmailAddress) 2577 } 2578 2579 if v.PhoneNumber != nil { 2580 ok := object.Key("PhoneNumber") 2581 ok.String(*v.PhoneNumber) 2582 } 2583 2584 if v.ProfileId != nil { 2585 ok := object.Key("ProfileId") 2586 ok.String(*v.ProfileId) 2587 } 2588 2589 if v.ShippingAddress != nil { 2590 ok := object.Key("ShippingAddress") 2591 if err := awsRestjson1_serializeDocumentUpdateAddress(v.ShippingAddress, ok); err != nil { 2592 return err 2593 } 2594 } 2595 2596 return nil 2597} 2598 2599func awsRestjson1_serializeDocumentAddress(v *types.Address, value smithyjson.Value) error { 2600 object := value.Object() 2601 defer object.Close() 2602 2603 if v.Address1 != nil { 2604 ok := object.Key("Address1") 2605 ok.String(*v.Address1) 2606 } 2607 2608 if v.Address2 != nil { 2609 ok := object.Key("Address2") 2610 ok.String(*v.Address2) 2611 } 2612 2613 if v.Address3 != nil { 2614 ok := object.Key("Address3") 2615 ok.String(*v.Address3) 2616 } 2617 2618 if v.Address4 != nil { 2619 ok := object.Key("Address4") 2620 ok.String(*v.Address4) 2621 } 2622 2623 if v.City != nil { 2624 ok := object.Key("City") 2625 ok.String(*v.City) 2626 } 2627 2628 if v.Country != nil { 2629 ok := object.Key("Country") 2630 ok.String(*v.Country) 2631 } 2632 2633 if v.County != nil { 2634 ok := object.Key("County") 2635 ok.String(*v.County) 2636 } 2637 2638 if v.PostalCode != nil { 2639 ok := object.Key("PostalCode") 2640 ok.String(*v.PostalCode) 2641 } 2642 2643 if v.Province != nil { 2644 ok := object.Key("Province") 2645 ok.String(*v.Province) 2646 } 2647 2648 if v.State != nil { 2649 ok := object.Key("State") 2650 ok.String(*v.State) 2651 } 2652 2653 return nil 2654} 2655 2656func awsRestjson1_serializeDocumentAttributes(v map[string]string, value smithyjson.Value) error { 2657 object := value.Object() 2658 defer object.Close() 2659 2660 for key := range v { 2661 om := object.Key(key) 2662 om.String(v[key]) 2663 } 2664 return nil 2665} 2666 2667func awsRestjson1_serializeDocumentFieldMap(v map[string]types.ObjectTypeField, value smithyjson.Value) error { 2668 object := value.Object() 2669 defer object.Close() 2670 2671 for key := range v { 2672 om := object.Key(key) 2673 mapVar := v[key] 2674 if err := awsRestjson1_serializeDocumentObjectTypeField(&mapVar, om); err != nil { 2675 return err 2676 } 2677 } 2678 return nil 2679} 2680 2681func awsRestjson1_serializeDocumentFieldNameList(v []string, value smithyjson.Value) error { 2682 array := value.Array() 2683 defer array.Close() 2684 2685 for i := range v { 2686 av := array.Value() 2687 av.String(v[i]) 2688 } 2689 return nil 2690} 2691 2692func awsRestjson1_serializeDocumentKeyMap(v map[string][]types.ObjectTypeKey, value smithyjson.Value) error { 2693 object := value.Object() 2694 defer object.Close() 2695 2696 for key := range v { 2697 om := object.Key(key) 2698 if vv := v[key]; vv == nil { 2699 continue 2700 } 2701 if err := awsRestjson1_serializeDocumentObjectTypeKeyList(v[key], om); err != nil { 2702 return err 2703 } 2704 } 2705 return nil 2706} 2707 2708func awsRestjson1_serializeDocumentObjectTypeField(v *types.ObjectTypeField, value smithyjson.Value) error { 2709 object := value.Object() 2710 defer object.Close() 2711 2712 if len(v.ContentType) > 0 { 2713 ok := object.Key("ContentType") 2714 ok.String(string(v.ContentType)) 2715 } 2716 2717 if v.Source != nil { 2718 ok := object.Key("Source") 2719 ok.String(*v.Source) 2720 } 2721 2722 if v.Target != nil { 2723 ok := object.Key("Target") 2724 ok.String(*v.Target) 2725 } 2726 2727 return nil 2728} 2729 2730func awsRestjson1_serializeDocumentObjectTypeKey(v *types.ObjectTypeKey, value smithyjson.Value) error { 2731 object := value.Object() 2732 defer object.Close() 2733 2734 if v.FieldNames != nil { 2735 ok := object.Key("FieldNames") 2736 if err := awsRestjson1_serializeDocumentFieldNameList(v.FieldNames, ok); err != nil { 2737 return err 2738 } 2739 } 2740 2741 if v.StandardIdentifiers != nil { 2742 ok := object.Key("StandardIdentifiers") 2743 if err := awsRestjson1_serializeDocumentStandardIdentifierList(v.StandardIdentifiers, ok); err != nil { 2744 return err 2745 } 2746 } 2747 2748 return nil 2749} 2750 2751func awsRestjson1_serializeDocumentObjectTypeKeyList(v []types.ObjectTypeKey, value smithyjson.Value) error { 2752 array := value.Array() 2753 defer array.Close() 2754 2755 for i := range v { 2756 av := array.Value() 2757 if err := awsRestjson1_serializeDocumentObjectTypeKey(&v[i], av); err != nil { 2758 return err 2759 } 2760 } 2761 return nil 2762} 2763 2764func awsRestjson1_serializeDocumentRequestValueList(v []string, value smithyjson.Value) error { 2765 array := value.Array() 2766 defer array.Close() 2767 2768 for i := range v { 2769 av := array.Value() 2770 av.String(v[i]) 2771 } 2772 return nil 2773} 2774 2775func awsRestjson1_serializeDocumentStandardIdentifierList(v []types.StandardIdentifier, value smithyjson.Value) error { 2776 array := value.Array() 2777 defer array.Close() 2778 2779 for i := range v { 2780 av := array.Value() 2781 av.String(string(v[i])) 2782 } 2783 return nil 2784} 2785 2786func awsRestjson1_serializeDocumentTagMap(v map[string]string, value smithyjson.Value) error { 2787 object := value.Object() 2788 defer object.Close() 2789 2790 for key := range v { 2791 om := object.Key(key) 2792 om.String(v[key]) 2793 } 2794 return nil 2795} 2796 2797func awsRestjson1_serializeDocumentUpdateAddress(v *types.UpdateAddress, value smithyjson.Value) error { 2798 object := value.Object() 2799 defer object.Close() 2800 2801 if v.Address1 != nil { 2802 ok := object.Key("Address1") 2803 ok.String(*v.Address1) 2804 } 2805 2806 if v.Address2 != nil { 2807 ok := object.Key("Address2") 2808 ok.String(*v.Address2) 2809 } 2810 2811 if v.Address3 != nil { 2812 ok := object.Key("Address3") 2813 ok.String(*v.Address3) 2814 } 2815 2816 if v.Address4 != nil { 2817 ok := object.Key("Address4") 2818 ok.String(*v.Address4) 2819 } 2820 2821 if v.City != nil { 2822 ok := object.Key("City") 2823 ok.String(*v.City) 2824 } 2825 2826 if v.Country != nil { 2827 ok := object.Key("Country") 2828 ok.String(*v.Country) 2829 } 2830 2831 if v.County != nil { 2832 ok := object.Key("County") 2833 ok.String(*v.County) 2834 } 2835 2836 if v.PostalCode != nil { 2837 ok := object.Key("PostalCode") 2838 ok.String(*v.PostalCode) 2839 } 2840 2841 if v.Province != nil { 2842 ok := object.Key("Province") 2843 ok.String(*v.Province) 2844 } 2845 2846 if v.State != nil { 2847 ok := object.Key("State") 2848 ok.String(*v.State) 2849 } 2850 2851 return nil 2852} 2853 2854func awsRestjson1_serializeDocumentUpdateAttributes(v map[string]string, value smithyjson.Value) error { 2855 object := value.Object() 2856 defer object.Close() 2857 2858 for key := range v { 2859 om := object.Key(key) 2860 om.String(v[key]) 2861 } 2862 return nil 2863} 2864