1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package cognitoidentityprovider 4 5import ( 6 "context" 7 "fmt" 8 "github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider/types" 9 smithy "github.com/aws/smithy-go" 10 "github.com/aws/smithy-go/middleware" 11) 12 13type validateOpAddCustomAttributes struct { 14} 15 16func (*validateOpAddCustomAttributes) ID() string { 17 return "OperationInputValidation" 18} 19 20func (m *validateOpAddCustomAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 21 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 22) { 23 input, ok := in.Parameters.(*AddCustomAttributesInput) 24 if !ok { 25 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 26 } 27 if err := validateOpAddCustomAttributesInput(input); err != nil { 28 return out, metadata, err 29 } 30 return next.HandleInitialize(ctx, in) 31} 32 33type validateOpAdminAddUserToGroup struct { 34} 35 36func (*validateOpAdminAddUserToGroup) ID() string { 37 return "OperationInputValidation" 38} 39 40func (m *validateOpAdminAddUserToGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 41 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 42) { 43 input, ok := in.Parameters.(*AdminAddUserToGroupInput) 44 if !ok { 45 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 46 } 47 if err := validateOpAdminAddUserToGroupInput(input); err != nil { 48 return out, metadata, err 49 } 50 return next.HandleInitialize(ctx, in) 51} 52 53type validateOpAdminConfirmSignUp struct { 54} 55 56func (*validateOpAdminConfirmSignUp) ID() string { 57 return "OperationInputValidation" 58} 59 60func (m *validateOpAdminConfirmSignUp) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 61 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 62) { 63 input, ok := in.Parameters.(*AdminConfirmSignUpInput) 64 if !ok { 65 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 66 } 67 if err := validateOpAdminConfirmSignUpInput(input); err != nil { 68 return out, metadata, err 69 } 70 return next.HandleInitialize(ctx, in) 71} 72 73type validateOpAdminCreateUser struct { 74} 75 76func (*validateOpAdminCreateUser) ID() string { 77 return "OperationInputValidation" 78} 79 80func (m *validateOpAdminCreateUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 81 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 82) { 83 input, ok := in.Parameters.(*AdminCreateUserInput) 84 if !ok { 85 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 86 } 87 if err := validateOpAdminCreateUserInput(input); err != nil { 88 return out, metadata, err 89 } 90 return next.HandleInitialize(ctx, in) 91} 92 93type validateOpAdminDeleteUserAttributes struct { 94} 95 96func (*validateOpAdminDeleteUserAttributes) ID() string { 97 return "OperationInputValidation" 98} 99 100func (m *validateOpAdminDeleteUserAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 101 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 102) { 103 input, ok := in.Parameters.(*AdminDeleteUserAttributesInput) 104 if !ok { 105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 106 } 107 if err := validateOpAdminDeleteUserAttributesInput(input); err != nil { 108 return out, metadata, err 109 } 110 return next.HandleInitialize(ctx, in) 111} 112 113type validateOpAdminDeleteUser struct { 114} 115 116func (*validateOpAdminDeleteUser) ID() string { 117 return "OperationInputValidation" 118} 119 120func (m *validateOpAdminDeleteUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 121 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 122) { 123 input, ok := in.Parameters.(*AdminDeleteUserInput) 124 if !ok { 125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 126 } 127 if err := validateOpAdminDeleteUserInput(input); err != nil { 128 return out, metadata, err 129 } 130 return next.HandleInitialize(ctx, in) 131} 132 133type validateOpAdminDisableProviderForUser struct { 134} 135 136func (*validateOpAdminDisableProviderForUser) ID() string { 137 return "OperationInputValidation" 138} 139 140func (m *validateOpAdminDisableProviderForUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 141 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 142) { 143 input, ok := in.Parameters.(*AdminDisableProviderForUserInput) 144 if !ok { 145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 146 } 147 if err := validateOpAdminDisableProviderForUserInput(input); err != nil { 148 return out, metadata, err 149 } 150 return next.HandleInitialize(ctx, in) 151} 152 153type validateOpAdminDisableUser struct { 154} 155 156func (*validateOpAdminDisableUser) ID() string { 157 return "OperationInputValidation" 158} 159 160func (m *validateOpAdminDisableUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 161 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 162) { 163 input, ok := in.Parameters.(*AdminDisableUserInput) 164 if !ok { 165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 166 } 167 if err := validateOpAdminDisableUserInput(input); err != nil { 168 return out, metadata, err 169 } 170 return next.HandleInitialize(ctx, in) 171} 172 173type validateOpAdminEnableUser struct { 174} 175 176func (*validateOpAdminEnableUser) ID() string { 177 return "OperationInputValidation" 178} 179 180func (m *validateOpAdminEnableUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 181 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 182) { 183 input, ok := in.Parameters.(*AdminEnableUserInput) 184 if !ok { 185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 186 } 187 if err := validateOpAdminEnableUserInput(input); err != nil { 188 return out, metadata, err 189 } 190 return next.HandleInitialize(ctx, in) 191} 192 193type validateOpAdminForgetDevice struct { 194} 195 196func (*validateOpAdminForgetDevice) ID() string { 197 return "OperationInputValidation" 198} 199 200func (m *validateOpAdminForgetDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 201 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 202) { 203 input, ok := in.Parameters.(*AdminForgetDeviceInput) 204 if !ok { 205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 206 } 207 if err := validateOpAdminForgetDeviceInput(input); err != nil { 208 return out, metadata, err 209 } 210 return next.HandleInitialize(ctx, in) 211} 212 213type validateOpAdminGetDevice struct { 214} 215 216func (*validateOpAdminGetDevice) ID() string { 217 return "OperationInputValidation" 218} 219 220func (m *validateOpAdminGetDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 221 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 222) { 223 input, ok := in.Parameters.(*AdminGetDeviceInput) 224 if !ok { 225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 226 } 227 if err := validateOpAdminGetDeviceInput(input); err != nil { 228 return out, metadata, err 229 } 230 return next.HandleInitialize(ctx, in) 231} 232 233type validateOpAdminGetUser struct { 234} 235 236func (*validateOpAdminGetUser) ID() string { 237 return "OperationInputValidation" 238} 239 240func (m *validateOpAdminGetUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 241 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 242) { 243 input, ok := in.Parameters.(*AdminGetUserInput) 244 if !ok { 245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 246 } 247 if err := validateOpAdminGetUserInput(input); err != nil { 248 return out, metadata, err 249 } 250 return next.HandleInitialize(ctx, in) 251} 252 253type validateOpAdminInitiateAuth struct { 254} 255 256func (*validateOpAdminInitiateAuth) ID() string { 257 return "OperationInputValidation" 258} 259 260func (m *validateOpAdminInitiateAuth) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 261 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 262) { 263 input, ok := in.Parameters.(*AdminInitiateAuthInput) 264 if !ok { 265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 266 } 267 if err := validateOpAdminInitiateAuthInput(input); err != nil { 268 return out, metadata, err 269 } 270 return next.HandleInitialize(ctx, in) 271} 272 273type validateOpAdminLinkProviderForUser struct { 274} 275 276func (*validateOpAdminLinkProviderForUser) ID() string { 277 return "OperationInputValidation" 278} 279 280func (m *validateOpAdminLinkProviderForUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 281 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 282) { 283 input, ok := in.Parameters.(*AdminLinkProviderForUserInput) 284 if !ok { 285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 286 } 287 if err := validateOpAdminLinkProviderForUserInput(input); err != nil { 288 return out, metadata, err 289 } 290 return next.HandleInitialize(ctx, in) 291} 292 293type validateOpAdminListDevices struct { 294} 295 296func (*validateOpAdminListDevices) ID() string { 297 return "OperationInputValidation" 298} 299 300func (m *validateOpAdminListDevices) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 301 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 302) { 303 input, ok := in.Parameters.(*AdminListDevicesInput) 304 if !ok { 305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 306 } 307 if err := validateOpAdminListDevicesInput(input); err != nil { 308 return out, metadata, err 309 } 310 return next.HandleInitialize(ctx, in) 311} 312 313type validateOpAdminListGroupsForUser struct { 314} 315 316func (*validateOpAdminListGroupsForUser) ID() string { 317 return "OperationInputValidation" 318} 319 320func (m *validateOpAdminListGroupsForUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 321 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 322) { 323 input, ok := in.Parameters.(*AdminListGroupsForUserInput) 324 if !ok { 325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 326 } 327 if err := validateOpAdminListGroupsForUserInput(input); err != nil { 328 return out, metadata, err 329 } 330 return next.HandleInitialize(ctx, in) 331} 332 333type validateOpAdminListUserAuthEvents struct { 334} 335 336func (*validateOpAdminListUserAuthEvents) ID() string { 337 return "OperationInputValidation" 338} 339 340func (m *validateOpAdminListUserAuthEvents) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 341 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 342) { 343 input, ok := in.Parameters.(*AdminListUserAuthEventsInput) 344 if !ok { 345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 346 } 347 if err := validateOpAdminListUserAuthEventsInput(input); err != nil { 348 return out, metadata, err 349 } 350 return next.HandleInitialize(ctx, in) 351} 352 353type validateOpAdminRemoveUserFromGroup struct { 354} 355 356func (*validateOpAdminRemoveUserFromGroup) ID() string { 357 return "OperationInputValidation" 358} 359 360func (m *validateOpAdminRemoveUserFromGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 361 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 362) { 363 input, ok := in.Parameters.(*AdminRemoveUserFromGroupInput) 364 if !ok { 365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 366 } 367 if err := validateOpAdminRemoveUserFromGroupInput(input); err != nil { 368 return out, metadata, err 369 } 370 return next.HandleInitialize(ctx, in) 371} 372 373type validateOpAdminResetUserPassword struct { 374} 375 376func (*validateOpAdminResetUserPassword) ID() string { 377 return "OperationInputValidation" 378} 379 380func (m *validateOpAdminResetUserPassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 381 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 382) { 383 input, ok := in.Parameters.(*AdminResetUserPasswordInput) 384 if !ok { 385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 386 } 387 if err := validateOpAdminResetUserPasswordInput(input); err != nil { 388 return out, metadata, err 389 } 390 return next.HandleInitialize(ctx, in) 391} 392 393type validateOpAdminRespondToAuthChallenge struct { 394} 395 396func (*validateOpAdminRespondToAuthChallenge) ID() string { 397 return "OperationInputValidation" 398} 399 400func (m *validateOpAdminRespondToAuthChallenge) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 401 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 402) { 403 input, ok := in.Parameters.(*AdminRespondToAuthChallengeInput) 404 if !ok { 405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 406 } 407 if err := validateOpAdminRespondToAuthChallengeInput(input); err != nil { 408 return out, metadata, err 409 } 410 return next.HandleInitialize(ctx, in) 411} 412 413type validateOpAdminSetUserMFAPreference struct { 414} 415 416func (*validateOpAdminSetUserMFAPreference) ID() string { 417 return "OperationInputValidation" 418} 419 420func (m *validateOpAdminSetUserMFAPreference) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 421 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 422) { 423 input, ok := in.Parameters.(*AdminSetUserMFAPreferenceInput) 424 if !ok { 425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 426 } 427 if err := validateOpAdminSetUserMFAPreferenceInput(input); err != nil { 428 return out, metadata, err 429 } 430 return next.HandleInitialize(ctx, in) 431} 432 433type validateOpAdminSetUserPassword struct { 434} 435 436func (*validateOpAdminSetUserPassword) ID() string { 437 return "OperationInputValidation" 438} 439 440func (m *validateOpAdminSetUserPassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 441 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 442) { 443 input, ok := in.Parameters.(*AdminSetUserPasswordInput) 444 if !ok { 445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 446 } 447 if err := validateOpAdminSetUserPasswordInput(input); err != nil { 448 return out, metadata, err 449 } 450 return next.HandleInitialize(ctx, in) 451} 452 453type validateOpAdminSetUserSettings struct { 454} 455 456func (*validateOpAdminSetUserSettings) ID() string { 457 return "OperationInputValidation" 458} 459 460func (m *validateOpAdminSetUserSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 461 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 462) { 463 input, ok := in.Parameters.(*AdminSetUserSettingsInput) 464 if !ok { 465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 466 } 467 if err := validateOpAdminSetUserSettingsInput(input); err != nil { 468 return out, metadata, err 469 } 470 return next.HandleInitialize(ctx, in) 471} 472 473type validateOpAdminUpdateAuthEventFeedback struct { 474} 475 476func (*validateOpAdminUpdateAuthEventFeedback) ID() string { 477 return "OperationInputValidation" 478} 479 480func (m *validateOpAdminUpdateAuthEventFeedback) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 481 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 482) { 483 input, ok := in.Parameters.(*AdminUpdateAuthEventFeedbackInput) 484 if !ok { 485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 486 } 487 if err := validateOpAdminUpdateAuthEventFeedbackInput(input); err != nil { 488 return out, metadata, err 489 } 490 return next.HandleInitialize(ctx, in) 491} 492 493type validateOpAdminUpdateDeviceStatus struct { 494} 495 496func (*validateOpAdminUpdateDeviceStatus) ID() string { 497 return "OperationInputValidation" 498} 499 500func (m *validateOpAdminUpdateDeviceStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 501 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 502) { 503 input, ok := in.Parameters.(*AdminUpdateDeviceStatusInput) 504 if !ok { 505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 506 } 507 if err := validateOpAdminUpdateDeviceStatusInput(input); err != nil { 508 return out, metadata, err 509 } 510 return next.HandleInitialize(ctx, in) 511} 512 513type validateOpAdminUpdateUserAttributes struct { 514} 515 516func (*validateOpAdminUpdateUserAttributes) ID() string { 517 return "OperationInputValidation" 518} 519 520func (m *validateOpAdminUpdateUserAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 521 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 522) { 523 input, ok := in.Parameters.(*AdminUpdateUserAttributesInput) 524 if !ok { 525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 526 } 527 if err := validateOpAdminUpdateUserAttributesInput(input); err != nil { 528 return out, metadata, err 529 } 530 return next.HandleInitialize(ctx, in) 531} 532 533type validateOpAdminUserGlobalSignOut struct { 534} 535 536func (*validateOpAdminUserGlobalSignOut) ID() string { 537 return "OperationInputValidation" 538} 539 540func (m *validateOpAdminUserGlobalSignOut) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 541 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 542) { 543 input, ok := in.Parameters.(*AdminUserGlobalSignOutInput) 544 if !ok { 545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 546 } 547 if err := validateOpAdminUserGlobalSignOutInput(input); err != nil { 548 return out, metadata, err 549 } 550 return next.HandleInitialize(ctx, in) 551} 552 553type validateOpChangePassword struct { 554} 555 556func (*validateOpChangePassword) ID() string { 557 return "OperationInputValidation" 558} 559 560func (m *validateOpChangePassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 561 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 562) { 563 input, ok := in.Parameters.(*ChangePasswordInput) 564 if !ok { 565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 566 } 567 if err := validateOpChangePasswordInput(input); err != nil { 568 return out, metadata, err 569 } 570 return next.HandleInitialize(ctx, in) 571} 572 573type validateOpConfirmDevice struct { 574} 575 576func (*validateOpConfirmDevice) ID() string { 577 return "OperationInputValidation" 578} 579 580func (m *validateOpConfirmDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 581 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 582) { 583 input, ok := in.Parameters.(*ConfirmDeviceInput) 584 if !ok { 585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 586 } 587 if err := validateOpConfirmDeviceInput(input); err != nil { 588 return out, metadata, err 589 } 590 return next.HandleInitialize(ctx, in) 591} 592 593type validateOpConfirmForgotPassword struct { 594} 595 596func (*validateOpConfirmForgotPassword) ID() string { 597 return "OperationInputValidation" 598} 599 600func (m *validateOpConfirmForgotPassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 601 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 602) { 603 input, ok := in.Parameters.(*ConfirmForgotPasswordInput) 604 if !ok { 605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 606 } 607 if err := validateOpConfirmForgotPasswordInput(input); err != nil { 608 return out, metadata, err 609 } 610 return next.HandleInitialize(ctx, in) 611} 612 613type validateOpConfirmSignUp struct { 614} 615 616func (*validateOpConfirmSignUp) ID() string { 617 return "OperationInputValidation" 618} 619 620func (m *validateOpConfirmSignUp) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 621 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 622) { 623 input, ok := in.Parameters.(*ConfirmSignUpInput) 624 if !ok { 625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 626 } 627 if err := validateOpConfirmSignUpInput(input); err != nil { 628 return out, metadata, err 629 } 630 return next.HandleInitialize(ctx, in) 631} 632 633type validateOpCreateGroup struct { 634} 635 636func (*validateOpCreateGroup) ID() string { 637 return "OperationInputValidation" 638} 639 640func (m *validateOpCreateGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 641 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 642) { 643 input, ok := in.Parameters.(*CreateGroupInput) 644 if !ok { 645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 646 } 647 if err := validateOpCreateGroupInput(input); err != nil { 648 return out, metadata, err 649 } 650 return next.HandleInitialize(ctx, in) 651} 652 653type validateOpCreateIdentityProvider struct { 654} 655 656func (*validateOpCreateIdentityProvider) ID() string { 657 return "OperationInputValidation" 658} 659 660func (m *validateOpCreateIdentityProvider) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 661 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 662) { 663 input, ok := in.Parameters.(*CreateIdentityProviderInput) 664 if !ok { 665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 666 } 667 if err := validateOpCreateIdentityProviderInput(input); err != nil { 668 return out, metadata, err 669 } 670 return next.HandleInitialize(ctx, in) 671} 672 673type validateOpCreateResourceServer struct { 674} 675 676func (*validateOpCreateResourceServer) ID() string { 677 return "OperationInputValidation" 678} 679 680func (m *validateOpCreateResourceServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 681 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 682) { 683 input, ok := in.Parameters.(*CreateResourceServerInput) 684 if !ok { 685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 686 } 687 if err := validateOpCreateResourceServerInput(input); err != nil { 688 return out, metadata, err 689 } 690 return next.HandleInitialize(ctx, in) 691} 692 693type validateOpCreateUserImportJob struct { 694} 695 696func (*validateOpCreateUserImportJob) ID() string { 697 return "OperationInputValidation" 698} 699 700func (m *validateOpCreateUserImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 701 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 702) { 703 input, ok := in.Parameters.(*CreateUserImportJobInput) 704 if !ok { 705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 706 } 707 if err := validateOpCreateUserImportJobInput(input); err != nil { 708 return out, metadata, err 709 } 710 return next.HandleInitialize(ctx, in) 711} 712 713type validateOpCreateUserPoolClient struct { 714} 715 716func (*validateOpCreateUserPoolClient) ID() string { 717 return "OperationInputValidation" 718} 719 720func (m *validateOpCreateUserPoolClient) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 721 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 722) { 723 input, ok := in.Parameters.(*CreateUserPoolClientInput) 724 if !ok { 725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 726 } 727 if err := validateOpCreateUserPoolClientInput(input); err != nil { 728 return out, metadata, err 729 } 730 return next.HandleInitialize(ctx, in) 731} 732 733type validateOpCreateUserPoolDomain struct { 734} 735 736func (*validateOpCreateUserPoolDomain) ID() string { 737 return "OperationInputValidation" 738} 739 740func (m *validateOpCreateUserPoolDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 741 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 742) { 743 input, ok := in.Parameters.(*CreateUserPoolDomainInput) 744 if !ok { 745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 746 } 747 if err := validateOpCreateUserPoolDomainInput(input); err != nil { 748 return out, metadata, err 749 } 750 return next.HandleInitialize(ctx, in) 751} 752 753type validateOpCreateUserPool struct { 754} 755 756func (*validateOpCreateUserPool) ID() string { 757 return "OperationInputValidation" 758} 759 760func (m *validateOpCreateUserPool) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 761 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 762) { 763 input, ok := in.Parameters.(*CreateUserPoolInput) 764 if !ok { 765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 766 } 767 if err := validateOpCreateUserPoolInput(input); err != nil { 768 return out, metadata, err 769 } 770 return next.HandleInitialize(ctx, in) 771} 772 773type validateOpDeleteGroup struct { 774} 775 776func (*validateOpDeleteGroup) ID() string { 777 return "OperationInputValidation" 778} 779 780func (m *validateOpDeleteGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 781 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 782) { 783 input, ok := in.Parameters.(*DeleteGroupInput) 784 if !ok { 785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 786 } 787 if err := validateOpDeleteGroupInput(input); err != nil { 788 return out, metadata, err 789 } 790 return next.HandleInitialize(ctx, in) 791} 792 793type validateOpDeleteIdentityProvider struct { 794} 795 796func (*validateOpDeleteIdentityProvider) ID() string { 797 return "OperationInputValidation" 798} 799 800func (m *validateOpDeleteIdentityProvider) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 801 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 802) { 803 input, ok := in.Parameters.(*DeleteIdentityProviderInput) 804 if !ok { 805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 806 } 807 if err := validateOpDeleteIdentityProviderInput(input); err != nil { 808 return out, metadata, err 809 } 810 return next.HandleInitialize(ctx, in) 811} 812 813type validateOpDeleteResourceServer struct { 814} 815 816func (*validateOpDeleteResourceServer) ID() string { 817 return "OperationInputValidation" 818} 819 820func (m *validateOpDeleteResourceServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 821 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 822) { 823 input, ok := in.Parameters.(*DeleteResourceServerInput) 824 if !ok { 825 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 826 } 827 if err := validateOpDeleteResourceServerInput(input); err != nil { 828 return out, metadata, err 829 } 830 return next.HandleInitialize(ctx, in) 831} 832 833type validateOpDeleteUserAttributes struct { 834} 835 836func (*validateOpDeleteUserAttributes) ID() string { 837 return "OperationInputValidation" 838} 839 840func (m *validateOpDeleteUserAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 841 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 842) { 843 input, ok := in.Parameters.(*DeleteUserAttributesInput) 844 if !ok { 845 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 846 } 847 if err := validateOpDeleteUserAttributesInput(input); err != nil { 848 return out, metadata, err 849 } 850 return next.HandleInitialize(ctx, in) 851} 852 853type validateOpDeleteUser struct { 854} 855 856func (*validateOpDeleteUser) ID() string { 857 return "OperationInputValidation" 858} 859 860func (m *validateOpDeleteUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 861 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 862) { 863 input, ok := in.Parameters.(*DeleteUserInput) 864 if !ok { 865 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 866 } 867 if err := validateOpDeleteUserInput(input); err != nil { 868 return out, metadata, err 869 } 870 return next.HandleInitialize(ctx, in) 871} 872 873type validateOpDeleteUserPoolClient struct { 874} 875 876func (*validateOpDeleteUserPoolClient) ID() string { 877 return "OperationInputValidation" 878} 879 880func (m *validateOpDeleteUserPoolClient) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 881 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 882) { 883 input, ok := in.Parameters.(*DeleteUserPoolClientInput) 884 if !ok { 885 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 886 } 887 if err := validateOpDeleteUserPoolClientInput(input); err != nil { 888 return out, metadata, err 889 } 890 return next.HandleInitialize(ctx, in) 891} 892 893type validateOpDeleteUserPoolDomain struct { 894} 895 896func (*validateOpDeleteUserPoolDomain) ID() string { 897 return "OperationInputValidation" 898} 899 900func (m *validateOpDeleteUserPoolDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 901 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 902) { 903 input, ok := in.Parameters.(*DeleteUserPoolDomainInput) 904 if !ok { 905 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 906 } 907 if err := validateOpDeleteUserPoolDomainInput(input); err != nil { 908 return out, metadata, err 909 } 910 return next.HandleInitialize(ctx, in) 911} 912 913type validateOpDeleteUserPool struct { 914} 915 916func (*validateOpDeleteUserPool) ID() string { 917 return "OperationInputValidation" 918} 919 920func (m *validateOpDeleteUserPool) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 921 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 922) { 923 input, ok := in.Parameters.(*DeleteUserPoolInput) 924 if !ok { 925 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 926 } 927 if err := validateOpDeleteUserPoolInput(input); err != nil { 928 return out, metadata, err 929 } 930 return next.HandleInitialize(ctx, in) 931} 932 933type validateOpDescribeIdentityProvider struct { 934} 935 936func (*validateOpDescribeIdentityProvider) ID() string { 937 return "OperationInputValidation" 938} 939 940func (m *validateOpDescribeIdentityProvider) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 941 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 942) { 943 input, ok := in.Parameters.(*DescribeIdentityProviderInput) 944 if !ok { 945 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 946 } 947 if err := validateOpDescribeIdentityProviderInput(input); err != nil { 948 return out, metadata, err 949 } 950 return next.HandleInitialize(ctx, in) 951} 952 953type validateOpDescribeResourceServer struct { 954} 955 956func (*validateOpDescribeResourceServer) ID() string { 957 return "OperationInputValidation" 958} 959 960func (m *validateOpDescribeResourceServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 961 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 962) { 963 input, ok := in.Parameters.(*DescribeResourceServerInput) 964 if !ok { 965 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 966 } 967 if err := validateOpDescribeResourceServerInput(input); err != nil { 968 return out, metadata, err 969 } 970 return next.HandleInitialize(ctx, in) 971} 972 973type validateOpDescribeRiskConfiguration struct { 974} 975 976func (*validateOpDescribeRiskConfiguration) ID() string { 977 return "OperationInputValidation" 978} 979 980func (m *validateOpDescribeRiskConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 981 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 982) { 983 input, ok := in.Parameters.(*DescribeRiskConfigurationInput) 984 if !ok { 985 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 986 } 987 if err := validateOpDescribeRiskConfigurationInput(input); err != nil { 988 return out, metadata, err 989 } 990 return next.HandleInitialize(ctx, in) 991} 992 993type validateOpDescribeUserImportJob struct { 994} 995 996func (*validateOpDescribeUserImportJob) ID() string { 997 return "OperationInputValidation" 998} 999 1000func (m *validateOpDescribeUserImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1001 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1002) { 1003 input, ok := in.Parameters.(*DescribeUserImportJobInput) 1004 if !ok { 1005 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1006 } 1007 if err := validateOpDescribeUserImportJobInput(input); err != nil { 1008 return out, metadata, err 1009 } 1010 return next.HandleInitialize(ctx, in) 1011} 1012 1013type validateOpDescribeUserPoolClient struct { 1014} 1015 1016func (*validateOpDescribeUserPoolClient) ID() string { 1017 return "OperationInputValidation" 1018} 1019 1020func (m *validateOpDescribeUserPoolClient) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1021 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1022) { 1023 input, ok := in.Parameters.(*DescribeUserPoolClientInput) 1024 if !ok { 1025 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1026 } 1027 if err := validateOpDescribeUserPoolClientInput(input); err != nil { 1028 return out, metadata, err 1029 } 1030 return next.HandleInitialize(ctx, in) 1031} 1032 1033type validateOpDescribeUserPoolDomain struct { 1034} 1035 1036func (*validateOpDescribeUserPoolDomain) ID() string { 1037 return "OperationInputValidation" 1038} 1039 1040func (m *validateOpDescribeUserPoolDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1041 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1042) { 1043 input, ok := in.Parameters.(*DescribeUserPoolDomainInput) 1044 if !ok { 1045 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1046 } 1047 if err := validateOpDescribeUserPoolDomainInput(input); err != nil { 1048 return out, metadata, err 1049 } 1050 return next.HandleInitialize(ctx, in) 1051} 1052 1053type validateOpDescribeUserPool struct { 1054} 1055 1056func (*validateOpDescribeUserPool) ID() string { 1057 return "OperationInputValidation" 1058} 1059 1060func (m *validateOpDescribeUserPool) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1061 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1062) { 1063 input, ok := in.Parameters.(*DescribeUserPoolInput) 1064 if !ok { 1065 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1066 } 1067 if err := validateOpDescribeUserPoolInput(input); err != nil { 1068 return out, metadata, err 1069 } 1070 return next.HandleInitialize(ctx, in) 1071} 1072 1073type validateOpForgetDevice struct { 1074} 1075 1076func (*validateOpForgetDevice) ID() string { 1077 return "OperationInputValidation" 1078} 1079 1080func (m *validateOpForgetDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1081 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1082) { 1083 input, ok := in.Parameters.(*ForgetDeviceInput) 1084 if !ok { 1085 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1086 } 1087 if err := validateOpForgetDeviceInput(input); err != nil { 1088 return out, metadata, err 1089 } 1090 return next.HandleInitialize(ctx, in) 1091} 1092 1093type validateOpForgotPassword struct { 1094} 1095 1096func (*validateOpForgotPassword) ID() string { 1097 return "OperationInputValidation" 1098} 1099 1100func (m *validateOpForgotPassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1101 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1102) { 1103 input, ok := in.Parameters.(*ForgotPasswordInput) 1104 if !ok { 1105 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1106 } 1107 if err := validateOpForgotPasswordInput(input); err != nil { 1108 return out, metadata, err 1109 } 1110 return next.HandleInitialize(ctx, in) 1111} 1112 1113type validateOpGetCSVHeader struct { 1114} 1115 1116func (*validateOpGetCSVHeader) ID() string { 1117 return "OperationInputValidation" 1118} 1119 1120func (m *validateOpGetCSVHeader) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1121 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1122) { 1123 input, ok := in.Parameters.(*GetCSVHeaderInput) 1124 if !ok { 1125 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1126 } 1127 if err := validateOpGetCSVHeaderInput(input); err != nil { 1128 return out, metadata, err 1129 } 1130 return next.HandleInitialize(ctx, in) 1131} 1132 1133type validateOpGetDevice struct { 1134} 1135 1136func (*validateOpGetDevice) ID() string { 1137 return "OperationInputValidation" 1138} 1139 1140func (m *validateOpGetDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1141 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1142) { 1143 input, ok := in.Parameters.(*GetDeviceInput) 1144 if !ok { 1145 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1146 } 1147 if err := validateOpGetDeviceInput(input); err != nil { 1148 return out, metadata, err 1149 } 1150 return next.HandleInitialize(ctx, in) 1151} 1152 1153type validateOpGetGroup struct { 1154} 1155 1156func (*validateOpGetGroup) ID() string { 1157 return "OperationInputValidation" 1158} 1159 1160func (m *validateOpGetGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1161 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1162) { 1163 input, ok := in.Parameters.(*GetGroupInput) 1164 if !ok { 1165 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1166 } 1167 if err := validateOpGetGroupInput(input); err != nil { 1168 return out, metadata, err 1169 } 1170 return next.HandleInitialize(ctx, in) 1171} 1172 1173type validateOpGetIdentityProviderByIdentifier struct { 1174} 1175 1176func (*validateOpGetIdentityProviderByIdentifier) ID() string { 1177 return "OperationInputValidation" 1178} 1179 1180func (m *validateOpGetIdentityProviderByIdentifier) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1181 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1182) { 1183 input, ok := in.Parameters.(*GetIdentityProviderByIdentifierInput) 1184 if !ok { 1185 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1186 } 1187 if err := validateOpGetIdentityProviderByIdentifierInput(input); err != nil { 1188 return out, metadata, err 1189 } 1190 return next.HandleInitialize(ctx, in) 1191} 1192 1193type validateOpGetSigningCertificate struct { 1194} 1195 1196func (*validateOpGetSigningCertificate) ID() string { 1197 return "OperationInputValidation" 1198} 1199 1200func (m *validateOpGetSigningCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1201 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1202) { 1203 input, ok := in.Parameters.(*GetSigningCertificateInput) 1204 if !ok { 1205 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1206 } 1207 if err := validateOpGetSigningCertificateInput(input); err != nil { 1208 return out, metadata, err 1209 } 1210 return next.HandleInitialize(ctx, in) 1211} 1212 1213type validateOpGetUICustomization struct { 1214} 1215 1216func (*validateOpGetUICustomization) ID() string { 1217 return "OperationInputValidation" 1218} 1219 1220func (m *validateOpGetUICustomization) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1221 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1222) { 1223 input, ok := in.Parameters.(*GetUICustomizationInput) 1224 if !ok { 1225 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1226 } 1227 if err := validateOpGetUICustomizationInput(input); err != nil { 1228 return out, metadata, err 1229 } 1230 return next.HandleInitialize(ctx, in) 1231} 1232 1233type validateOpGetUserAttributeVerificationCode struct { 1234} 1235 1236func (*validateOpGetUserAttributeVerificationCode) ID() string { 1237 return "OperationInputValidation" 1238} 1239 1240func (m *validateOpGetUserAttributeVerificationCode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1241 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1242) { 1243 input, ok := in.Parameters.(*GetUserAttributeVerificationCodeInput) 1244 if !ok { 1245 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1246 } 1247 if err := validateOpGetUserAttributeVerificationCodeInput(input); err != nil { 1248 return out, metadata, err 1249 } 1250 return next.HandleInitialize(ctx, in) 1251} 1252 1253type validateOpGetUser struct { 1254} 1255 1256func (*validateOpGetUser) ID() string { 1257 return "OperationInputValidation" 1258} 1259 1260func (m *validateOpGetUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1261 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1262) { 1263 input, ok := in.Parameters.(*GetUserInput) 1264 if !ok { 1265 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1266 } 1267 if err := validateOpGetUserInput(input); err != nil { 1268 return out, metadata, err 1269 } 1270 return next.HandleInitialize(ctx, in) 1271} 1272 1273type validateOpGetUserPoolMfaConfig struct { 1274} 1275 1276func (*validateOpGetUserPoolMfaConfig) ID() string { 1277 return "OperationInputValidation" 1278} 1279 1280func (m *validateOpGetUserPoolMfaConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1281 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1282) { 1283 input, ok := in.Parameters.(*GetUserPoolMfaConfigInput) 1284 if !ok { 1285 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1286 } 1287 if err := validateOpGetUserPoolMfaConfigInput(input); err != nil { 1288 return out, metadata, err 1289 } 1290 return next.HandleInitialize(ctx, in) 1291} 1292 1293type validateOpGlobalSignOut struct { 1294} 1295 1296func (*validateOpGlobalSignOut) ID() string { 1297 return "OperationInputValidation" 1298} 1299 1300func (m *validateOpGlobalSignOut) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1301 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1302) { 1303 input, ok := in.Parameters.(*GlobalSignOutInput) 1304 if !ok { 1305 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1306 } 1307 if err := validateOpGlobalSignOutInput(input); err != nil { 1308 return out, metadata, err 1309 } 1310 return next.HandleInitialize(ctx, in) 1311} 1312 1313type validateOpInitiateAuth struct { 1314} 1315 1316func (*validateOpInitiateAuth) ID() string { 1317 return "OperationInputValidation" 1318} 1319 1320func (m *validateOpInitiateAuth) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1321 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1322) { 1323 input, ok := in.Parameters.(*InitiateAuthInput) 1324 if !ok { 1325 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1326 } 1327 if err := validateOpInitiateAuthInput(input); err != nil { 1328 return out, metadata, err 1329 } 1330 return next.HandleInitialize(ctx, in) 1331} 1332 1333type validateOpListDevices struct { 1334} 1335 1336func (*validateOpListDevices) ID() string { 1337 return "OperationInputValidation" 1338} 1339 1340func (m *validateOpListDevices) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1341 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1342) { 1343 input, ok := in.Parameters.(*ListDevicesInput) 1344 if !ok { 1345 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1346 } 1347 if err := validateOpListDevicesInput(input); err != nil { 1348 return out, metadata, err 1349 } 1350 return next.HandleInitialize(ctx, in) 1351} 1352 1353type validateOpListGroups struct { 1354} 1355 1356func (*validateOpListGroups) ID() string { 1357 return "OperationInputValidation" 1358} 1359 1360func (m *validateOpListGroups) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1361 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1362) { 1363 input, ok := in.Parameters.(*ListGroupsInput) 1364 if !ok { 1365 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1366 } 1367 if err := validateOpListGroupsInput(input); err != nil { 1368 return out, metadata, err 1369 } 1370 return next.HandleInitialize(ctx, in) 1371} 1372 1373type validateOpListIdentityProviders struct { 1374} 1375 1376func (*validateOpListIdentityProviders) ID() string { 1377 return "OperationInputValidation" 1378} 1379 1380func (m *validateOpListIdentityProviders) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1381 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1382) { 1383 input, ok := in.Parameters.(*ListIdentityProvidersInput) 1384 if !ok { 1385 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1386 } 1387 if err := validateOpListIdentityProvidersInput(input); err != nil { 1388 return out, metadata, err 1389 } 1390 return next.HandleInitialize(ctx, in) 1391} 1392 1393type validateOpListResourceServers struct { 1394} 1395 1396func (*validateOpListResourceServers) ID() string { 1397 return "OperationInputValidation" 1398} 1399 1400func (m *validateOpListResourceServers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1401 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1402) { 1403 input, ok := in.Parameters.(*ListResourceServersInput) 1404 if !ok { 1405 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1406 } 1407 if err := validateOpListResourceServersInput(input); err != nil { 1408 return out, metadata, err 1409 } 1410 return next.HandleInitialize(ctx, in) 1411} 1412 1413type validateOpListTagsForResource struct { 1414} 1415 1416func (*validateOpListTagsForResource) ID() string { 1417 return "OperationInputValidation" 1418} 1419 1420func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1421 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1422) { 1423 input, ok := in.Parameters.(*ListTagsForResourceInput) 1424 if !ok { 1425 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1426 } 1427 if err := validateOpListTagsForResourceInput(input); err != nil { 1428 return out, metadata, err 1429 } 1430 return next.HandleInitialize(ctx, in) 1431} 1432 1433type validateOpListUserImportJobs struct { 1434} 1435 1436func (*validateOpListUserImportJobs) ID() string { 1437 return "OperationInputValidation" 1438} 1439 1440func (m *validateOpListUserImportJobs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1441 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1442) { 1443 input, ok := in.Parameters.(*ListUserImportJobsInput) 1444 if !ok { 1445 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1446 } 1447 if err := validateOpListUserImportJobsInput(input); err != nil { 1448 return out, metadata, err 1449 } 1450 return next.HandleInitialize(ctx, in) 1451} 1452 1453type validateOpListUserPoolClients struct { 1454} 1455 1456func (*validateOpListUserPoolClients) ID() string { 1457 return "OperationInputValidation" 1458} 1459 1460func (m *validateOpListUserPoolClients) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1461 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1462) { 1463 input, ok := in.Parameters.(*ListUserPoolClientsInput) 1464 if !ok { 1465 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1466 } 1467 if err := validateOpListUserPoolClientsInput(input); err != nil { 1468 return out, metadata, err 1469 } 1470 return next.HandleInitialize(ctx, in) 1471} 1472 1473type validateOpListUserPools struct { 1474} 1475 1476func (*validateOpListUserPools) ID() string { 1477 return "OperationInputValidation" 1478} 1479 1480func (m *validateOpListUserPools) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1481 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1482) { 1483 input, ok := in.Parameters.(*ListUserPoolsInput) 1484 if !ok { 1485 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1486 } 1487 if err := validateOpListUserPoolsInput(input); err != nil { 1488 return out, metadata, err 1489 } 1490 return next.HandleInitialize(ctx, in) 1491} 1492 1493type validateOpListUsersInGroup struct { 1494} 1495 1496func (*validateOpListUsersInGroup) ID() string { 1497 return "OperationInputValidation" 1498} 1499 1500func (m *validateOpListUsersInGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1501 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1502) { 1503 input, ok := in.Parameters.(*ListUsersInGroupInput) 1504 if !ok { 1505 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1506 } 1507 if err := validateOpListUsersInGroupInput(input); err != nil { 1508 return out, metadata, err 1509 } 1510 return next.HandleInitialize(ctx, in) 1511} 1512 1513type validateOpListUsers struct { 1514} 1515 1516func (*validateOpListUsers) ID() string { 1517 return "OperationInputValidation" 1518} 1519 1520func (m *validateOpListUsers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1521 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1522) { 1523 input, ok := in.Parameters.(*ListUsersInput) 1524 if !ok { 1525 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1526 } 1527 if err := validateOpListUsersInput(input); err != nil { 1528 return out, metadata, err 1529 } 1530 return next.HandleInitialize(ctx, in) 1531} 1532 1533type validateOpResendConfirmationCode struct { 1534} 1535 1536func (*validateOpResendConfirmationCode) ID() string { 1537 return "OperationInputValidation" 1538} 1539 1540func (m *validateOpResendConfirmationCode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1541 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1542) { 1543 input, ok := in.Parameters.(*ResendConfirmationCodeInput) 1544 if !ok { 1545 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1546 } 1547 if err := validateOpResendConfirmationCodeInput(input); err != nil { 1548 return out, metadata, err 1549 } 1550 return next.HandleInitialize(ctx, in) 1551} 1552 1553type validateOpRespondToAuthChallenge struct { 1554} 1555 1556func (*validateOpRespondToAuthChallenge) ID() string { 1557 return "OperationInputValidation" 1558} 1559 1560func (m *validateOpRespondToAuthChallenge) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1561 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1562) { 1563 input, ok := in.Parameters.(*RespondToAuthChallengeInput) 1564 if !ok { 1565 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1566 } 1567 if err := validateOpRespondToAuthChallengeInput(input); err != nil { 1568 return out, metadata, err 1569 } 1570 return next.HandleInitialize(ctx, in) 1571} 1572 1573type validateOpRevokeToken struct { 1574} 1575 1576func (*validateOpRevokeToken) ID() string { 1577 return "OperationInputValidation" 1578} 1579 1580func (m *validateOpRevokeToken) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1581 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1582) { 1583 input, ok := in.Parameters.(*RevokeTokenInput) 1584 if !ok { 1585 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1586 } 1587 if err := validateOpRevokeTokenInput(input); err != nil { 1588 return out, metadata, err 1589 } 1590 return next.HandleInitialize(ctx, in) 1591} 1592 1593type validateOpSetRiskConfiguration struct { 1594} 1595 1596func (*validateOpSetRiskConfiguration) ID() string { 1597 return "OperationInputValidation" 1598} 1599 1600func (m *validateOpSetRiskConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1601 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1602) { 1603 input, ok := in.Parameters.(*SetRiskConfigurationInput) 1604 if !ok { 1605 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1606 } 1607 if err := validateOpSetRiskConfigurationInput(input); err != nil { 1608 return out, metadata, err 1609 } 1610 return next.HandleInitialize(ctx, in) 1611} 1612 1613type validateOpSetUICustomization struct { 1614} 1615 1616func (*validateOpSetUICustomization) ID() string { 1617 return "OperationInputValidation" 1618} 1619 1620func (m *validateOpSetUICustomization) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1621 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1622) { 1623 input, ok := in.Parameters.(*SetUICustomizationInput) 1624 if !ok { 1625 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1626 } 1627 if err := validateOpSetUICustomizationInput(input); err != nil { 1628 return out, metadata, err 1629 } 1630 return next.HandleInitialize(ctx, in) 1631} 1632 1633type validateOpSetUserMFAPreference struct { 1634} 1635 1636func (*validateOpSetUserMFAPreference) ID() string { 1637 return "OperationInputValidation" 1638} 1639 1640func (m *validateOpSetUserMFAPreference) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1641 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1642) { 1643 input, ok := in.Parameters.(*SetUserMFAPreferenceInput) 1644 if !ok { 1645 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1646 } 1647 if err := validateOpSetUserMFAPreferenceInput(input); err != nil { 1648 return out, metadata, err 1649 } 1650 return next.HandleInitialize(ctx, in) 1651} 1652 1653type validateOpSetUserPoolMfaConfig struct { 1654} 1655 1656func (*validateOpSetUserPoolMfaConfig) ID() string { 1657 return "OperationInputValidation" 1658} 1659 1660func (m *validateOpSetUserPoolMfaConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1661 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1662) { 1663 input, ok := in.Parameters.(*SetUserPoolMfaConfigInput) 1664 if !ok { 1665 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1666 } 1667 if err := validateOpSetUserPoolMfaConfigInput(input); err != nil { 1668 return out, metadata, err 1669 } 1670 return next.HandleInitialize(ctx, in) 1671} 1672 1673type validateOpSetUserSettings struct { 1674} 1675 1676func (*validateOpSetUserSettings) ID() string { 1677 return "OperationInputValidation" 1678} 1679 1680func (m *validateOpSetUserSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1681 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1682) { 1683 input, ok := in.Parameters.(*SetUserSettingsInput) 1684 if !ok { 1685 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1686 } 1687 if err := validateOpSetUserSettingsInput(input); err != nil { 1688 return out, metadata, err 1689 } 1690 return next.HandleInitialize(ctx, in) 1691} 1692 1693type validateOpSignUp struct { 1694} 1695 1696func (*validateOpSignUp) ID() string { 1697 return "OperationInputValidation" 1698} 1699 1700func (m *validateOpSignUp) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1701 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1702) { 1703 input, ok := in.Parameters.(*SignUpInput) 1704 if !ok { 1705 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1706 } 1707 if err := validateOpSignUpInput(input); err != nil { 1708 return out, metadata, err 1709 } 1710 return next.HandleInitialize(ctx, in) 1711} 1712 1713type validateOpStartUserImportJob struct { 1714} 1715 1716func (*validateOpStartUserImportJob) ID() string { 1717 return "OperationInputValidation" 1718} 1719 1720func (m *validateOpStartUserImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1721 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1722) { 1723 input, ok := in.Parameters.(*StartUserImportJobInput) 1724 if !ok { 1725 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1726 } 1727 if err := validateOpStartUserImportJobInput(input); err != nil { 1728 return out, metadata, err 1729 } 1730 return next.HandleInitialize(ctx, in) 1731} 1732 1733type validateOpStopUserImportJob struct { 1734} 1735 1736func (*validateOpStopUserImportJob) ID() string { 1737 return "OperationInputValidation" 1738} 1739 1740func (m *validateOpStopUserImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1741 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1742) { 1743 input, ok := in.Parameters.(*StopUserImportJobInput) 1744 if !ok { 1745 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1746 } 1747 if err := validateOpStopUserImportJobInput(input); err != nil { 1748 return out, metadata, err 1749 } 1750 return next.HandleInitialize(ctx, in) 1751} 1752 1753type validateOpTagResource struct { 1754} 1755 1756func (*validateOpTagResource) ID() string { 1757 return "OperationInputValidation" 1758} 1759 1760func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1761 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1762) { 1763 input, ok := in.Parameters.(*TagResourceInput) 1764 if !ok { 1765 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1766 } 1767 if err := validateOpTagResourceInput(input); err != nil { 1768 return out, metadata, err 1769 } 1770 return next.HandleInitialize(ctx, in) 1771} 1772 1773type validateOpUntagResource struct { 1774} 1775 1776func (*validateOpUntagResource) ID() string { 1777 return "OperationInputValidation" 1778} 1779 1780func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1781 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1782) { 1783 input, ok := in.Parameters.(*UntagResourceInput) 1784 if !ok { 1785 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1786 } 1787 if err := validateOpUntagResourceInput(input); err != nil { 1788 return out, metadata, err 1789 } 1790 return next.HandleInitialize(ctx, in) 1791} 1792 1793type validateOpUpdateAuthEventFeedback struct { 1794} 1795 1796func (*validateOpUpdateAuthEventFeedback) ID() string { 1797 return "OperationInputValidation" 1798} 1799 1800func (m *validateOpUpdateAuthEventFeedback) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1801 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1802) { 1803 input, ok := in.Parameters.(*UpdateAuthEventFeedbackInput) 1804 if !ok { 1805 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1806 } 1807 if err := validateOpUpdateAuthEventFeedbackInput(input); err != nil { 1808 return out, metadata, err 1809 } 1810 return next.HandleInitialize(ctx, in) 1811} 1812 1813type validateOpUpdateDeviceStatus struct { 1814} 1815 1816func (*validateOpUpdateDeviceStatus) ID() string { 1817 return "OperationInputValidation" 1818} 1819 1820func (m *validateOpUpdateDeviceStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1821 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1822) { 1823 input, ok := in.Parameters.(*UpdateDeviceStatusInput) 1824 if !ok { 1825 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1826 } 1827 if err := validateOpUpdateDeviceStatusInput(input); err != nil { 1828 return out, metadata, err 1829 } 1830 return next.HandleInitialize(ctx, in) 1831} 1832 1833type validateOpUpdateGroup struct { 1834} 1835 1836func (*validateOpUpdateGroup) ID() string { 1837 return "OperationInputValidation" 1838} 1839 1840func (m *validateOpUpdateGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1841 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1842) { 1843 input, ok := in.Parameters.(*UpdateGroupInput) 1844 if !ok { 1845 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1846 } 1847 if err := validateOpUpdateGroupInput(input); err != nil { 1848 return out, metadata, err 1849 } 1850 return next.HandleInitialize(ctx, in) 1851} 1852 1853type validateOpUpdateIdentityProvider struct { 1854} 1855 1856func (*validateOpUpdateIdentityProvider) ID() string { 1857 return "OperationInputValidation" 1858} 1859 1860func (m *validateOpUpdateIdentityProvider) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1861 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1862) { 1863 input, ok := in.Parameters.(*UpdateIdentityProviderInput) 1864 if !ok { 1865 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1866 } 1867 if err := validateOpUpdateIdentityProviderInput(input); err != nil { 1868 return out, metadata, err 1869 } 1870 return next.HandleInitialize(ctx, in) 1871} 1872 1873type validateOpUpdateResourceServer struct { 1874} 1875 1876func (*validateOpUpdateResourceServer) ID() string { 1877 return "OperationInputValidation" 1878} 1879 1880func (m *validateOpUpdateResourceServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1881 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1882) { 1883 input, ok := in.Parameters.(*UpdateResourceServerInput) 1884 if !ok { 1885 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1886 } 1887 if err := validateOpUpdateResourceServerInput(input); err != nil { 1888 return out, metadata, err 1889 } 1890 return next.HandleInitialize(ctx, in) 1891} 1892 1893type validateOpUpdateUserAttributes struct { 1894} 1895 1896func (*validateOpUpdateUserAttributes) ID() string { 1897 return "OperationInputValidation" 1898} 1899 1900func (m *validateOpUpdateUserAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1901 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1902) { 1903 input, ok := in.Parameters.(*UpdateUserAttributesInput) 1904 if !ok { 1905 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1906 } 1907 if err := validateOpUpdateUserAttributesInput(input); err != nil { 1908 return out, metadata, err 1909 } 1910 return next.HandleInitialize(ctx, in) 1911} 1912 1913type validateOpUpdateUserPoolClient struct { 1914} 1915 1916func (*validateOpUpdateUserPoolClient) ID() string { 1917 return "OperationInputValidation" 1918} 1919 1920func (m *validateOpUpdateUserPoolClient) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1921 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1922) { 1923 input, ok := in.Parameters.(*UpdateUserPoolClientInput) 1924 if !ok { 1925 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1926 } 1927 if err := validateOpUpdateUserPoolClientInput(input); err != nil { 1928 return out, metadata, err 1929 } 1930 return next.HandleInitialize(ctx, in) 1931} 1932 1933type validateOpUpdateUserPoolDomain struct { 1934} 1935 1936func (*validateOpUpdateUserPoolDomain) ID() string { 1937 return "OperationInputValidation" 1938} 1939 1940func (m *validateOpUpdateUserPoolDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1941 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1942) { 1943 input, ok := in.Parameters.(*UpdateUserPoolDomainInput) 1944 if !ok { 1945 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1946 } 1947 if err := validateOpUpdateUserPoolDomainInput(input); err != nil { 1948 return out, metadata, err 1949 } 1950 return next.HandleInitialize(ctx, in) 1951} 1952 1953type validateOpUpdateUserPool struct { 1954} 1955 1956func (*validateOpUpdateUserPool) ID() string { 1957 return "OperationInputValidation" 1958} 1959 1960func (m *validateOpUpdateUserPool) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1961 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1962) { 1963 input, ok := in.Parameters.(*UpdateUserPoolInput) 1964 if !ok { 1965 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1966 } 1967 if err := validateOpUpdateUserPoolInput(input); err != nil { 1968 return out, metadata, err 1969 } 1970 return next.HandleInitialize(ctx, in) 1971} 1972 1973type validateOpVerifySoftwareToken struct { 1974} 1975 1976func (*validateOpVerifySoftwareToken) ID() string { 1977 return "OperationInputValidation" 1978} 1979 1980func (m *validateOpVerifySoftwareToken) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 1981 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 1982) { 1983 input, ok := in.Parameters.(*VerifySoftwareTokenInput) 1984 if !ok { 1985 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 1986 } 1987 if err := validateOpVerifySoftwareTokenInput(input); err != nil { 1988 return out, metadata, err 1989 } 1990 return next.HandleInitialize(ctx, in) 1991} 1992 1993type validateOpVerifyUserAttribute struct { 1994} 1995 1996func (*validateOpVerifyUserAttribute) ID() string { 1997 return "OperationInputValidation" 1998} 1999 2000func (m *validateOpVerifyUserAttribute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) ( 2001 out middleware.InitializeOutput, metadata middleware.Metadata, err error, 2002) { 2003 input, ok := in.Parameters.(*VerifyUserAttributeInput) 2004 if !ok { 2005 return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters) 2006 } 2007 if err := validateOpVerifyUserAttributeInput(input); err != nil { 2008 return out, metadata, err 2009 } 2010 return next.HandleInitialize(ctx, in) 2011} 2012 2013func addOpAddCustomAttributesValidationMiddleware(stack *middleware.Stack) error { 2014 return stack.Initialize.Add(&validateOpAddCustomAttributes{}, middleware.After) 2015} 2016 2017func addOpAdminAddUserToGroupValidationMiddleware(stack *middleware.Stack) error { 2018 return stack.Initialize.Add(&validateOpAdminAddUserToGroup{}, middleware.After) 2019} 2020 2021func addOpAdminConfirmSignUpValidationMiddleware(stack *middleware.Stack) error { 2022 return stack.Initialize.Add(&validateOpAdminConfirmSignUp{}, middleware.After) 2023} 2024 2025func addOpAdminCreateUserValidationMiddleware(stack *middleware.Stack) error { 2026 return stack.Initialize.Add(&validateOpAdminCreateUser{}, middleware.After) 2027} 2028 2029func addOpAdminDeleteUserAttributesValidationMiddleware(stack *middleware.Stack) error { 2030 return stack.Initialize.Add(&validateOpAdminDeleteUserAttributes{}, middleware.After) 2031} 2032 2033func addOpAdminDeleteUserValidationMiddleware(stack *middleware.Stack) error { 2034 return stack.Initialize.Add(&validateOpAdminDeleteUser{}, middleware.After) 2035} 2036 2037func addOpAdminDisableProviderForUserValidationMiddleware(stack *middleware.Stack) error { 2038 return stack.Initialize.Add(&validateOpAdminDisableProviderForUser{}, middleware.After) 2039} 2040 2041func addOpAdminDisableUserValidationMiddleware(stack *middleware.Stack) error { 2042 return stack.Initialize.Add(&validateOpAdminDisableUser{}, middleware.After) 2043} 2044 2045func addOpAdminEnableUserValidationMiddleware(stack *middleware.Stack) error { 2046 return stack.Initialize.Add(&validateOpAdminEnableUser{}, middleware.After) 2047} 2048 2049func addOpAdminForgetDeviceValidationMiddleware(stack *middleware.Stack) error { 2050 return stack.Initialize.Add(&validateOpAdminForgetDevice{}, middleware.After) 2051} 2052 2053func addOpAdminGetDeviceValidationMiddleware(stack *middleware.Stack) error { 2054 return stack.Initialize.Add(&validateOpAdminGetDevice{}, middleware.After) 2055} 2056 2057func addOpAdminGetUserValidationMiddleware(stack *middleware.Stack) error { 2058 return stack.Initialize.Add(&validateOpAdminGetUser{}, middleware.After) 2059} 2060 2061func addOpAdminInitiateAuthValidationMiddleware(stack *middleware.Stack) error { 2062 return stack.Initialize.Add(&validateOpAdminInitiateAuth{}, middleware.After) 2063} 2064 2065func addOpAdminLinkProviderForUserValidationMiddleware(stack *middleware.Stack) error { 2066 return stack.Initialize.Add(&validateOpAdminLinkProviderForUser{}, middleware.After) 2067} 2068 2069func addOpAdminListDevicesValidationMiddleware(stack *middleware.Stack) error { 2070 return stack.Initialize.Add(&validateOpAdminListDevices{}, middleware.After) 2071} 2072 2073func addOpAdminListGroupsForUserValidationMiddleware(stack *middleware.Stack) error { 2074 return stack.Initialize.Add(&validateOpAdminListGroupsForUser{}, middleware.After) 2075} 2076 2077func addOpAdminListUserAuthEventsValidationMiddleware(stack *middleware.Stack) error { 2078 return stack.Initialize.Add(&validateOpAdminListUserAuthEvents{}, middleware.After) 2079} 2080 2081func addOpAdminRemoveUserFromGroupValidationMiddleware(stack *middleware.Stack) error { 2082 return stack.Initialize.Add(&validateOpAdminRemoveUserFromGroup{}, middleware.After) 2083} 2084 2085func addOpAdminResetUserPasswordValidationMiddleware(stack *middleware.Stack) error { 2086 return stack.Initialize.Add(&validateOpAdminResetUserPassword{}, middleware.After) 2087} 2088 2089func addOpAdminRespondToAuthChallengeValidationMiddleware(stack *middleware.Stack) error { 2090 return stack.Initialize.Add(&validateOpAdminRespondToAuthChallenge{}, middleware.After) 2091} 2092 2093func addOpAdminSetUserMFAPreferenceValidationMiddleware(stack *middleware.Stack) error { 2094 return stack.Initialize.Add(&validateOpAdminSetUserMFAPreference{}, middleware.After) 2095} 2096 2097func addOpAdminSetUserPasswordValidationMiddleware(stack *middleware.Stack) error { 2098 return stack.Initialize.Add(&validateOpAdminSetUserPassword{}, middleware.After) 2099} 2100 2101func addOpAdminSetUserSettingsValidationMiddleware(stack *middleware.Stack) error { 2102 return stack.Initialize.Add(&validateOpAdminSetUserSettings{}, middleware.After) 2103} 2104 2105func addOpAdminUpdateAuthEventFeedbackValidationMiddleware(stack *middleware.Stack) error { 2106 return stack.Initialize.Add(&validateOpAdminUpdateAuthEventFeedback{}, middleware.After) 2107} 2108 2109func addOpAdminUpdateDeviceStatusValidationMiddleware(stack *middleware.Stack) error { 2110 return stack.Initialize.Add(&validateOpAdminUpdateDeviceStatus{}, middleware.After) 2111} 2112 2113func addOpAdminUpdateUserAttributesValidationMiddleware(stack *middleware.Stack) error { 2114 return stack.Initialize.Add(&validateOpAdminUpdateUserAttributes{}, middleware.After) 2115} 2116 2117func addOpAdminUserGlobalSignOutValidationMiddleware(stack *middleware.Stack) error { 2118 return stack.Initialize.Add(&validateOpAdminUserGlobalSignOut{}, middleware.After) 2119} 2120 2121func addOpChangePasswordValidationMiddleware(stack *middleware.Stack) error { 2122 return stack.Initialize.Add(&validateOpChangePassword{}, middleware.After) 2123} 2124 2125func addOpConfirmDeviceValidationMiddleware(stack *middleware.Stack) error { 2126 return stack.Initialize.Add(&validateOpConfirmDevice{}, middleware.After) 2127} 2128 2129func addOpConfirmForgotPasswordValidationMiddleware(stack *middleware.Stack) error { 2130 return stack.Initialize.Add(&validateOpConfirmForgotPassword{}, middleware.After) 2131} 2132 2133func addOpConfirmSignUpValidationMiddleware(stack *middleware.Stack) error { 2134 return stack.Initialize.Add(&validateOpConfirmSignUp{}, middleware.After) 2135} 2136 2137func addOpCreateGroupValidationMiddleware(stack *middleware.Stack) error { 2138 return stack.Initialize.Add(&validateOpCreateGroup{}, middleware.After) 2139} 2140 2141func addOpCreateIdentityProviderValidationMiddleware(stack *middleware.Stack) error { 2142 return stack.Initialize.Add(&validateOpCreateIdentityProvider{}, middleware.After) 2143} 2144 2145func addOpCreateResourceServerValidationMiddleware(stack *middleware.Stack) error { 2146 return stack.Initialize.Add(&validateOpCreateResourceServer{}, middleware.After) 2147} 2148 2149func addOpCreateUserImportJobValidationMiddleware(stack *middleware.Stack) error { 2150 return stack.Initialize.Add(&validateOpCreateUserImportJob{}, middleware.After) 2151} 2152 2153func addOpCreateUserPoolClientValidationMiddleware(stack *middleware.Stack) error { 2154 return stack.Initialize.Add(&validateOpCreateUserPoolClient{}, middleware.After) 2155} 2156 2157func addOpCreateUserPoolDomainValidationMiddleware(stack *middleware.Stack) error { 2158 return stack.Initialize.Add(&validateOpCreateUserPoolDomain{}, middleware.After) 2159} 2160 2161func addOpCreateUserPoolValidationMiddleware(stack *middleware.Stack) error { 2162 return stack.Initialize.Add(&validateOpCreateUserPool{}, middleware.After) 2163} 2164 2165func addOpDeleteGroupValidationMiddleware(stack *middleware.Stack) error { 2166 return stack.Initialize.Add(&validateOpDeleteGroup{}, middleware.After) 2167} 2168 2169func addOpDeleteIdentityProviderValidationMiddleware(stack *middleware.Stack) error { 2170 return stack.Initialize.Add(&validateOpDeleteIdentityProvider{}, middleware.After) 2171} 2172 2173func addOpDeleteResourceServerValidationMiddleware(stack *middleware.Stack) error { 2174 return stack.Initialize.Add(&validateOpDeleteResourceServer{}, middleware.After) 2175} 2176 2177func addOpDeleteUserAttributesValidationMiddleware(stack *middleware.Stack) error { 2178 return stack.Initialize.Add(&validateOpDeleteUserAttributes{}, middleware.After) 2179} 2180 2181func addOpDeleteUserValidationMiddleware(stack *middleware.Stack) error { 2182 return stack.Initialize.Add(&validateOpDeleteUser{}, middleware.After) 2183} 2184 2185func addOpDeleteUserPoolClientValidationMiddleware(stack *middleware.Stack) error { 2186 return stack.Initialize.Add(&validateOpDeleteUserPoolClient{}, middleware.After) 2187} 2188 2189func addOpDeleteUserPoolDomainValidationMiddleware(stack *middleware.Stack) error { 2190 return stack.Initialize.Add(&validateOpDeleteUserPoolDomain{}, middleware.After) 2191} 2192 2193func addOpDeleteUserPoolValidationMiddleware(stack *middleware.Stack) error { 2194 return stack.Initialize.Add(&validateOpDeleteUserPool{}, middleware.After) 2195} 2196 2197func addOpDescribeIdentityProviderValidationMiddleware(stack *middleware.Stack) error { 2198 return stack.Initialize.Add(&validateOpDescribeIdentityProvider{}, middleware.After) 2199} 2200 2201func addOpDescribeResourceServerValidationMiddleware(stack *middleware.Stack) error { 2202 return stack.Initialize.Add(&validateOpDescribeResourceServer{}, middleware.After) 2203} 2204 2205func addOpDescribeRiskConfigurationValidationMiddleware(stack *middleware.Stack) error { 2206 return stack.Initialize.Add(&validateOpDescribeRiskConfiguration{}, middleware.After) 2207} 2208 2209func addOpDescribeUserImportJobValidationMiddleware(stack *middleware.Stack) error { 2210 return stack.Initialize.Add(&validateOpDescribeUserImportJob{}, middleware.After) 2211} 2212 2213func addOpDescribeUserPoolClientValidationMiddleware(stack *middleware.Stack) error { 2214 return stack.Initialize.Add(&validateOpDescribeUserPoolClient{}, middleware.After) 2215} 2216 2217func addOpDescribeUserPoolDomainValidationMiddleware(stack *middleware.Stack) error { 2218 return stack.Initialize.Add(&validateOpDescribeUserPoolDomain{}, middleware.After) 2219} 2220 2221func addOpDescribeUserPoolValidationMiddleware(stack *middleware.Stack) error { 2222 return stack.Initialize.Add(&validateOpDescribeUserPool{}, middleware.After) 2223} 2224 2225func addOpForgetDeviceValidationMiddleware(stack *middleware.Stack) error { 2226 return stack.Initialize.Add(&validateOpForgetDevice{}, middleware.After) 2227} 2228 2229func addOpForgotPasswordValidationMiddleware(stack *middleware.Stack) error { 2230 return stack.Initialize.Add(&validateOpForgotPassword{}, middleware.After) 2231} 2232 2233func addOpGetCSVHeaderValidationMiddleware(stack *middleware.Stack) error { 2234 return stack.Initialize.Add(&validateOpGetCSVHeader{}, middleware.After) 2235} 2236 2237func addOpGetDeviceValidationMiddleware(stack *middleware.Stack) error { 2238 return stack.Initialize.Add(&validateOpGetDevice{}, middleware.After) 2239} 2240 2241func addOpGetGroupValidationMiddleware(stack *middleware.Stack) error { 2242 return stack.Initialize.Add(&validateOpGetGroup{}, middleware.After) 2243} 2244 2245func addOpGetIdentityProviderByIdentifierValidationMiddleware(stack *middleware.Stack) error { 2246 return stack.Initialize.Add(&validateOpGetIdentityProviderByIdentifier{}, middleware.After) 2247} 2248 2249func addOpGetSigningCertificateValidationMiddleware(stack *middleware.Stack) error { 2250 return stack.Initialize.Add(&validateOpGetSigningCertificate{}, middleware.After) 2251} 2252 2253func addOpGetUICustomizationValidationMiddleware(stack *middleware.Stack) error { 2254 return stack.Initialize.Add(&validateOpGetUICustomization{}, middleware.After) 2255} 2256 2257func addOpGetUserAttributeVerificationCodeValidationMiddleware(stack *middleware.Stack) error { 2258 return stack.Initialize.Add(&validateOpGetUserAttributeVerificationCode{}, middleware.After) 2259} 2260 2261func addOpGetUserValidationMiddleware(stack *middleware.Stack) error { 2262 return stack.Initialize.Add(&validateOpGetUser{}, middleware.After) 2263} 2264 2265func addOpGetUserPoolMfaConfigValidationMiddleware(stack *middleware.Stack) error { 2266 return stack.Initialize.Add(&validateOpGetUserPoolMfaConfig{}, middleware.After) 2267} 2268 2269func addOpGlobalSignOutValidationMiddleware(stack *middleware.Stack) error { 2270 return stack.Initialize.Add(&validateOpGlobalSignOut{}, middleware.After) 2271} 2272 2273func addOpInitiateAuthValidationMiddleware(stack *middleware.Stack) error { 2274 return stack.Initialize.Add(&validateOpInitiateAuth{}, middleware.After) 2275} 2276 2277func addOpListDevicesValidationMiddleware(stack *middleware.Stack) error { 2278 return stack.Initialize.Add(&validateOpListDevices{}, middleware.After) 2279} 2280 2281func addOpListGroupsValidationMiddleware(stack *middleware.Stack) error { 2282 return stack.Initialize.Add(&validateOpListGroups{}, middleware.After) 2283} 2284 2285func addOpListIdentityProvidersValidationMiddleware(stack *middleware.Stack) error { 2286 return stack.Initialize.Add(&validateOpListIdentityProviders{}, middleware.After) 2287} 2288 2289func addOpListResourceServersValidationMiddleware(stack *middleware.Stack) error { 2290 return stack.Initialize.Add(&validateOpListResourceServers{}, middleware.After) 2291} 2292 2293func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error { 2294 return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After) 2295} 2296 2297func addOpListUserImportJobsValidationMiddleware(stack *middleware.Stack) error { 2298 return stack.Initialize.Add(&validateOpListUserImportJobs{}, middleware.After) 2299} 2300 2301func addOpListUserPoolClientsValidationMiddleware(stack *middleware.Stack) error { 2302 return stack.Initialize.Add(&validateOpListUserPoolClients{}, middleware.After) 2303} 2304 2305func addOpListUserPoolsValidationMiddleware(stack *middleware.Stack) error { 2306 return stack.Initialize.Add(&validateOpListUserPools{}, middleware.After) 2307} 2308 2309func addOpListUsersInGroupValidationMiddleware(stack *middleware.Stack) error { 2310 return stack.Initialize.Add(&validateOpListUsersInGroup{}, middleware.After) 2311} 2312 2313func addOpListUsersValidationMiddleware(stack *middleware.Stack) error { 2314 return stack.Initialize.Add(&validateOpListUsers{}, middleware.After) 2315} 2316 2317func addOpResendConfirmationCodeValidationMiddleware(stack *middleware.Stack) error { 2318 return stack.Initialize.Add(&validateOpResendConfirmationCode{}, middleware.After) 2319} 2320 2321func addOpRespondToAuthChallengeValidationMiddleware(stack *middleware.Stack) error { 2322 return stack.Initialize.Add(&validateOpRespondToAuthChallenge{}, middleware.After) 2323} 2324 2325func addOpRevokeTokenValidationMiddleware(stack *middleware.Stack) error { 2326 return stack.Initialize.Add(&validateOpRevokeToken{}, middleware.After) 2327} 2328 2329func addOpSetRiskConfigurationValidationMiddleware(stack *middleware.Stack) error { 2330 return stack.Initialize.Add(&validateOpSetRiskConfiguration{}, middleware.After) 2331} 2332 2333func addOpSetUICustomizationValidationMiddleware(stack *middleware.Stack) error { 2334 return stack.Initialize.Add(&validateOpSetUICustomization{}, middleware.After) 2335} 2336 2337func addOpSetUserMFAPreferenceValidationMiddleware(stack *middleware.Stack) error { 2338 return stack.Initialize.Add(&validateOpSetUserMFAPreference{}, middleware.After) 2339} 2340 2341func addOpSetUserPoolMfaConfigValidationMiddleware(stack *middleware.Stack) error { 2342 return stack.Initialize.Add(&validateOpSetUserPoolMfaConfig{}, middleware.After) 2343} 2344 2345func addOpSetUserSettingsValidationMiddleware(stack *middleware.Stack) error { 2346 return stack.Initialize.Add(&validateOpSetUserSettings{}, middleware.After) 2347} 2348 2349func addOpSignUpValidationMiddleware(stack *middleware.Stack) error { 2350 return stack.Initialize.Add(&validateOpSignUp{}, middleware.After) 2351} 2352 2353func addOpStartUserImportJobValidationMiddleware(stack *middleware.Stack) error { 2354 return stack.Initialize.Add(&validateOpStartUserImportJob{}, middleware.After) 2355} 2356 2357func addOpStopUserImportJobValidationMiddleware(stack *middleware.Stack) error { 2358 return stack.Initialize.Add(&validateOpStopUserImportJob{}, middleware.After) 2359} 2360 2361func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error { 2362 return stack.Initialize.Add(&validateOpTagResource{}, middleware.After) 2363} 2364 2365func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error { 2366 return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After) 2367} 2368 2369func addOpUpdateAuthEventFeedbackValidationMiddleware(stack *middleware.Stack) error { 2370 return stack.Initialize.Add(&validateOpUpdateAuthEventFeedback{}, middleware.After) 2371} 2372 2373func addOpUpdateDeviceStatusValidationMiddleware(stack *middleware.Stack) error { 2374 return stack.Initialize.Add(&validateOpUpdateDeviceStatus{}, middleware.After) 2375} 2376 2377func addOpUpdateGroupValidationMiddleware(stack *middleware.Stack) error { 2378 return stack.Initialize.Add(&validateOpUpdateGroup{}, middleware.After) 2379} 2380 2381func addOpUpdateIdentityProviderValidationMiddleware(stack *middleware.Stack) error { 2382 return stack.Initialize.Add(&validateOpUpdateIdentityProvider{}, middleware.After) 2383} 2384 2385func addOpUpdateResourceServerValidationMiddleware(stack *middleware.Stack) error { 2386 return stack.Initialize.Add(&validateOpUpdateResourceServer{}, middleware.After) 2387} 2388 2389func addOpUpdateUserAttributesValidationMiddleware(stack *middleware.Stack) error { 2390 return stack.Initialize.Add(&validateOpUpdateUserAttributes{}, middleware.After) 2391} 2392 2393func addOpUpdateUserPoolClientValidationMiddleware(stack *middleware.Stack) error { 2394 return stack.Initialize.Add(&validateOpUpdateUserPoolClient{}, middleware.After) 2395} 2396 2397func addOpUpdateUserPoolDomainValidationMiddleware(stack *middleware.Stack) error { 2398 return stack.Initialize.Add(&validateOpUpdateUserPoolDomain{}, middleware.After) 2399} 2400 2401func addOpUpdateUserPoolValidationMiddleware(stack *middleware.Stack) error { 2402 return stack.Initialize.Add(&validateOpUpdateUserPool{}, middleware.After) 2403} 2404 2405func addOpVerifySoftwareTokenValidationMiddleware(stack *middleware.Stack) error { 2406 return stack.Initialize.Add(&validateOpVerifySoftwareToken{}, middleware.After) 2407} 2408 2409func addOpVerifyUserAttributeValidationMiddleware(stack *middleware.Stack) error { 2410 return stack.Initialize.Add(&validateOpVerifyUserAttribute{}, middleware.After) 2411} 2412 2413func validateAccountRecoverySettingType(v *types.AccountRecoverySettingType) error { 2414 if v == nil { 2415 return nil 2416 } 2417 invalidParams := smithy.InvalidParamsError{Context: "AccountRecoverySettingType"} 2418 if v.RecoveryMechanisms != nil { 2419 if err := validateRecoveryMechanismsType(v.RecoveryMechanisms); err != nil { 2420 invalidParams.AddNested("RecoveryMechanisms", err.(smithy.InvalidParamsError)) 2421 } 2422 } 2423 if invalidParams.Len() > 0 { 2424 return invalidParams 2425 } else { 2426 return nil 2427 } 2428} 2429 2430func validateAccountTakeoverActionsType(v *types.AccountTakeoverActionsType) error { 2431 if v == nil { 2432 return nil 2433 } 2434 invalidParams := smithy.InvalidParamsError{Context: "AccountTakeoverActionsType"} 2435 if v.LowAction != nil { 2436 if err := validateAccountTakeoverActionType(v.LowAction); err != nil { 2437 invalidParams.AddNested("LowAction", err.(smithy.InvalidParamsError)) 2438 } 2439 } 2440 if v.MediumAction != nil { 2441 if err := validateAccountTakeoverActionType(v.MediumAction); err != nil { 2442 invalidParams.AddNested("MediumAction", err.(smithy.InvalidParamsError)) 2443 } 2444 } 2445 if v.HighAction != nil { 2446 if err := validateAccountTakeoverActionType(v.HighAction); err != nil { 2447 invalidParams.AddNested("HighAction", err.(smithy.InvalidParamsError)) 2448 } 2449 } 2450 if invalidParams.Len() > 0 { 2451 return invalidParams 2452 } else { 2453 return nil 2454 } 2455} 2456 2457func validateAccountTakeoverActionType(v *types.AccountTakeoverActionType) error { 2458 if v == nil { 2459 return nil 2460 } 2461 invalidParams := smithy.InvalidParamsError{Context: "AccountTakeoverActionType"} 2462 if len(v.EventAction) == 0 { 2463 invalidParams.Add(smithy.NewErrParamRequired("EventAction")) 2464 } 2465 if invalidParams.Len() > 0 { 2466 return invalidParams 2467 } else { 2468 return nil 2469 } 2470} 2471 2472func validateAccountTakeoverRiskConfigurationType(v *types.AccountTakeoverRiskConfigurationType) error { 2473 if v == nil { 2474 return nil 2475 } 2476 invalidParams := smithy.InvalidParamsError{Context: "AccountTakeoverRiskConfigurationType"} 2477 if v.NotifyConfiguration != nil { 2478 if err := validateNotifyConfigurationType(v.NotifyConfiguration); err != nil { 2479 invalidParams.AddNested("NotifyConfiguration", err.(smithy.InvalidParamsError)) 2480 } 2481 } 2482 if v.Actions == nil { 2483 invalidParams.Add(smithy.NewErrParamRequired("Actions")) 2484 } else if v.Actions != nil { 2485 if err := validateAccountTakeoverActionsType(v.Actions); err != nil { 2486 invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError)) 2487 } 2488 } 2489 if invalidParams.Len() > 0 { 2490 return invalidParams 2491 } else { 2492 return nil 2493 } 2494} 2495 2496func validateAttributeListType(v []types.AttributeType) error { 2497 if v == nil { 2498 return nil 2499 } 2500 invalidParams := smithy.InvalidParamsError{Context: "AttributeListType"} 2501 for i := range v { 2502 if err := validateAttributeType(&v[i]); err != nil { 2503 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2504 } 2505 } 2506 if invalidParams.Len() > 0 { 2507 return invalidParams 2508 } else { 2509 return nil 2510 } 2511} 2512 2513func validateAttributeType(v *types.AttributeType) error { 2514 if v == nil { 2515 return nil 2516 } 2517 invalidParams := smithy.InvalidParamsError{Context: "AttributeType"} 2518 if v.Name == nil { 2519 invalidParams.Add(smithy.NewErrParamRequired("Name")) 2520 } 2521 if invalidParams.Len() > 0 { 2522 return invalidParams 2523 } else { 2524 return nil 2525 } 2526} 2527 2528func validateCompromisedCredentialsActionsType(v *types.CompromisedCredentialsActionsType) error { 2529 if v == nil { 2530 return nil 2531 } 2532 invalidParams := smithy.InvalidParamsError{Context: "CompromisedCredentialsActionsType"} 2533 if len(v.EventAction) == 0 { 2534 invalidParams.Add(smithy.NewErrParamRequired("EventAction")) 2535 } 2536 if invalidParams.Len() > 0 { 2537 return invalidParams 2538 } else { 2539 return nil 2540 } 2541} 2542 2543func validateCompromisedCredentialsRiskConfigurationType(v *types.CompromisedCredentialsRiskConfigurationType) error { 2544 if v == nil { 2545 return nil 2546 } 2547 invalidParams := smithy.InvalidParamsError{Context: "CompromisedCredentialsRiskConfigurationType"} 2548 if v.Actions == nil { 2549 invalidParams.Add(smithy.NewErrParamRequired("Actions")) 2550 } else if v.Actions != nil { 2551 if err := validateCompromisedCredentialsActionsType(v.Actions); err != nil { 2552 invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError)) 2553 } 2554 } 2555 if invalidParams.Len() > 0 { 2556 return invalidParams 2557 } else { 2558 return nil 2559 } 2560} 2561 2562func validateContextDataType(v *types.ContextDataType) error { 2563 if v == nil { 2564 return nil 2565 } 2566 invalidParams := smithy.InvalidParamsError{Context: "ContextDataType"} 2567 if v.IpAddress == nil { 2568 invalidParams.Add(smithy.NewErrParamRequired("IpAddress")) 2569 } 2570 if v.ServerName == nil { 2571 invalidParams.Add(smithy.NewErrParamRequired("ServerName")) 2572 } 2573 if v.ServerPath == nil { 2574 invalidParams.Add(smithy.NewErrParamRequired("ServerPath")) 2575 } 2576 if v.HttpHeaders == nil { 2577 invalidParams.Add(smithy.NewErrParamRequired("HttpHeaders")) 2578 } 2579 if invalidParams.Len() > 0 { 2580 return invalidParams 2581 } else { 2582 return nil 2583 } 2584} 2585 2586func validateCustomDomainConfigType(v *types.CustomDomainConfigType) error { 2587 if v == nil { 2588 return nil 2589 } 2590 invalidParams := smithy.InvalidParamsError{Context: "CustomDomainConfigType"} 2591 if v.CertificateArn == nil { 2592 invalidParams.Add(smithy.NewErrParamRequired("CertificateArn")) 2593 } 2594 if invalidParams.Len() > 0 { 2595 return invalidParams 2596 } else { 2597 return nil 2598 } 2599} 2600 2601func validateCustomEmailLambdaVersionConfigType(v *types.CustomEmailLambdaVersionConfigType) error { 2602 if v == nil { 2603 return nil 2604 } 2605 invalidParams := smithy.InvalidParamsError{Context: "CustomEmailLambdaVersionConfigType"} 2606 if len(v.LambdaVersion) == 0 { 2607 invalidParams.Add(smithy.NewErrParamRequired("LambdaVersion")) 2608 } 2609 if v.LambdaArn == nil { 2610 invalidParams.Add(smithy.NewErrParamRequired("LambdaArn")) 2611 } 2612 if invalidParams.Len() > 0 { 2613 return invalidParams 2614 } else { 2615 return nil 2616 } 2617} 2618 2619func validateCustomSMSLambdaVersionConfigType(v *types.CustomSMSLambdaVersionConfigType) error { 2620 if v == nil { 2621 return nil 2622 } 2623 invalidParams := smithy.InvalidParamsError{Context: "CustomSMSLambdaVersionConfigType"} 2624 if len(v.LambdaVersion) == 0 { 2625 invalidParams.Add(smithy.NewErrParamRequired("LambdaVersion")) 2626 } 2627 if v.LambdaArn == nil { 2628 invalidParams.Add(smithy.NewErrParamRequired("LambdaArn")) 2629 } 2630 if invalidParams.Len() > 0 { 2631 return invalidParams 2632 } else { 2633 return nil 2634 } 2635} 2636 2637func validateLambdaConfigType(v *types.LambdaConfigType) error { 2638 if v == nil { 2639 return nil 2640 } 2641 invalidParams := smithy.InvalidParamsError{Context: "LambdaConfigType"} 2642 if v.CustomSMSSender != nil { 2643 if err := validateCustomSMSLambdaVersionConfigType(v.CustomSMSSender); err != nil { 2644 invalidParams.AddNested("CustomSMSSender", err.(smithy.InvalidParamsError)) 2645 } 2646 } 2647 if v.CustomEmailSender != nil { 2648 if err := validateCustomEmailLambdaVersionConfigType(v.CustomEmailSender); err != nil { 2649 invalidParams.AddNested("CustomEmailSender", err.(smithy.InvalidParamsError)) 2650 } 2651 } 2652 if invalidParams.Len() > 0 { 2653 return invalidParams 2654 } else { 2655 return nil 2656 } 2657} 2658 2659func validateNotifyConfigurationType(v *types.NotifyConfigurationType) error { 2660 if v == nil { 2661 return nil 2662 } 2663 invalidParams := smithy.InvalidParamsError{Context: "NotifyConfigurationType"} 2664 if v.SourceArn == nil { 2665 invalidParams.Add(smithy.NewErrParamRequired("SourceArn")) 2666 } 2667 if v.BlockEmail != nil { 2668 if err := validateNotifyEmailType(v.BlockEmail); err != nil { 2669 invalidParams.AddNested("BlockEmail", err.(smithy.InvalidParamsError)) 2670 } 2671 } 2672 if v.NoActionEmail != nil { 2673 if err := validateNotifyEmailType(v.NoActionEmail); err != nil { 2674 invalidParams.AddNested("NoActionEmail", err.(smithy.InvalidParamsError)) 2675 } 2676 } 2677 if v.MfaEmail != nil { 2678 if err := validateNotifyEmailType(v.MfaEmail); err != nil { 2679 invalidParams.AddNested("MfaEmail", err.(smithy.InvalidParamsError)) 2680 } 2681 } 2682 if invalidParams.Len() > 0 { 2683 return invalidParams 2684 } else { 2685 return nil 2686 } 2687} 2688 2689func validateNotifyEmailType(v *types.NotifyEmailType) error { 2690 if v == nil { 2691 return nil 2692 } 2693 invalidParams := smithy.InvalidParamsError{Context: "NotifyEmailType"} 2694 if v.Subject == nil { 2695 invalidParams.Add(smithy.NewErrParamRequired("Subject")) 2696 } 2697 if invalidParams.Len() > 0 { 2698 return invalidParams 2699 } else { 2700 return nil 2701 } 2702} 2703 2704func validateRecoveryMechanismsType(v []types.RecoveryOptionType) error { 2705 if v == nil { 2706 return nil 2707 } 2708 invalidParams := smithy.InvalidParamsError{Context: "RecoveryMechanismsType"} 2709 for i := range v { 2710 if err := validateRecoveryOptionType(&v[i]); err != nil { 2711 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2712 } 2713 } 2714 if invalidParams.Len() > 0 { 2715 return invalidParams 2716 } else { 2717 return nil 2718 } 2719} 2720 2721func validateRecoveryOptionType(v *types.RecoveryOptionType) error { 2722 if v == nil { 2723 return nil 2724 } 2725 invalidParams := smithy.InvalidParamsError{Context: "RecoveryOptionType"} 2726 if len(v.Name) == 0 { 2727 invalidParams.Add(smithy.NewErrParamRequired("Name")) 2728 } 2729 if invalidParams.Len() > 0 { 2730 return invalidParams 2731 } else { 2732 return nil 2733 } 2734} 2735 2736func validateResourceServerScopeListType(v []types.ResourceServerScopeType) error { 2737 if v == nil { 2738 return nil 2739 } 2740 invalidParams := smithy.InvalidParamsError{Context: "ResourceServerScopeListType"} 2741 for i := range v { 2742 if err := validateResourceServerScopeType(&v[i]); err != nil { 2743 invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError)) 2744 } 2745 } 2746 if invalidParams.Len() > 0 { 2747 return invalidParams 2748 } else { 2749 return nil 2750 } 2751} 2752 2753func validateResourceServerScopeType(v *types.ResourceServerScopeType) error { 2754 if v == nil { 2755 return nil 2756 } 2757 invalidParams := smithy.InvalidParamsError{Context: "ResourceServerScopeType"} 2758 if v.ScopeName == nil { 2759 invalidParams.Add(smithy.NewErrParamRequired("ScopeName")) 2760 } 2761 if v.ScopeDescription == nil { 2762 invalidParams.Add(smithy.NewErrParamRequired("ScopeDescription")) 2763 } 2764 if invalidParams.Len() > 0 { 2765 return invalidParams 2766 } else { 2767 return nil 2768 } 2769} 2770 2771func validateSmsConfigurationType(v *types.SmsConfigurationType) error { 2772 if v == nil { 2773 return nil 2774 } 2775 invalidParams := smithy.InvalidParamsError{Context: "SmsConfigurationType"} 2776 if v.SnsCallerArn == nil { 2777 invalidParams.Add(smithy.NewErrParamRequired("SnsCallerArn")) 2778 } 2779 if invalidParams.Len() > 0 { 2780 return invalidParams 2781 } else { 2782 return nil 2783 } 2784} 2785 2786func validateSmsMfaConfigType(v *types.SmsMfaConfigType) error { 2787 if v == nil { 2788 return nil 2789 } 2790 invalidParams := smithy.InvalidParamsError{Context: "SmsMfaConfigType"} 2791 if v.SmsConfiguration != nil { 2792 if err := validateSmsConfigurationType(v.SmsConfiguration); err != nil { 2793 invalidParams.AddNested("SmsConfiguration", err.(smithy.InvalidParamsError)) 2794 } 2795 } 2796 if invalidParams.Len() > 0 { 2797 return invalidParams 2798 } else { 2799 return nil 2800 } 2801} 2802 2803func validateUsernameConfigurationType(v *types.UsernameConfigurationType) error { 2804 if v == nil { 2805 return nil 2806 } 2807 invalidParams := smithy.InvalidParamsError{Context: "UsernameConfigurationType"} 2808 if v.CaseSensitive == nil { 2809 invalidParams.Add(smithy.NewErrParamRequired("CaseSensitive")) 2810 } 2811 if invalidParams.Len() > 0 { 2812 return invalidParams 2813 } else { 2814 return nil 2815 } 2816} 2817 2818func validateUserPoolAddOnsType(v *types.UserPoolAddOnsType) error { 2819 if v == nil { 2820 return nil 2821 } 2822 invalidParams := smithy.InvalidParamsError{Context: "UserPoolAddOnsType"} 2823 if len(v.AdvancedSecurityMode) == 0 { 2824 invalidParams.Add(smithy.NewErrParamRequired("AdvancedSecurityMode")) 2825 } 2826 if invalidParams.Len() > 0 { 2827 return invalidParams 2828 } else { 2829 return nil 2830 } 2831} 2832 2833func validateOpAddCustomAttributesInput(v *AddCustomAttributesInput) error { 2834 if v == nil { 2835 return nil 2836 } 2837 invalidParams := smithy.InvalidParamsError{Context: "AddCustomAttributesInput"} 2838 if v.UserPoolId == nil { 2839 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 2840 } 2841 if v.CustomAttributes == nil { 2842 invalidParams.Add(smithy.NewErrParamRequired("CustomAttributes")) 2843 } 2844 if invalidParams.Len() > 0 { 2845 return invalidParams 2846 } else { 2847 return nil 2848 } 2849} 2850 2851func validateOpAdminAddUserToGroupInput(v *AdminAddUserToGroupInput) error { 2852 if v == nil { 2853 return nil 2854 } 2855 invalidParams := smithy.InvalidParamsError{Context: "AdminAddUserToGroupInput"} 2856 if v.UserPoolId == nil { 2857 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 2858 } 2859 if v.Username == nil { 2860 invalidParams.Add(smithy.NewErrParamRequired("Username")) 2861 } 2862 if v.GroupName == nil { 2863 invalidParams.Add(smithy.NewErrParamRequired("GroupName")) 2864 } 2865 if invalidParams.Len() > 0 { 2866 return invalidParams 2867 } else { 2868 return nil 2869 } 2870} 2871 2872func validateOpAdminConfirmSignUpInput(v *AdminConfirmSignUpInput) error { 2873 if v == nil { 2874 return nil 2875 } 2876 invalidParams := smithy.InvalidParamsError{Context: "AdminConfirmSignUpInput"} 2877 if v.UserPoolId == nil { 2878 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 2879 } 2880 if v.Username == nil { 2881 invalidParams.Add(smithy.NewErrParamRequired("Username")) 2882 } 2883 if invalidParams.Len() > 0 { 2884 return invalidParams 2885 } else { 2886 return nil 2887 } 2888} 2889 2890func validateOpAdminCreateUserInput(v *AdminCreateUserInput) error { 2891 if v == nil { 2892 return nil 2893 } 2894 invalidParams := smithy.InvalidParamsError{Context: "AdminCreateUserInput"} 2895 if v.UserPoolId == nil { 2896 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 2897 } 2898 if v.Username == nil { 2899 invalidParams.Add(smithy.NewErrParamRequired("Username")) 2900 } 2901 if v.UserAttributes != nil { 2902 if err := validateAttributeListType(v.UserAttributes); err != nil { 2903 invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError)) 2904 } 2905 } 2906 if v.ValidationData != nil { 2907 if err := validateAttributeListType(v.ValidationData); err != nil { 2908 invalidParams.AddNested("ValidationData", err.(smithy.InvalidParamsError)) 2909 } 2910 } 2911 if invalidParams.Len() > 0 { 2912 return invalidParams 2913 } else { 2914 return nil 2915 } 2916} 2917 2918func validateOpAdminDeleteUserAttributesInput(v *AdminDeleteUserAttributesInput) error { 2919 if v == nil { 2920 return nil 2921 } 2922 invalidParams := smithy.InvalidParamsError{Context: "AdminDeleteUserAttributesInput"} 2923 if v.UserPoolId == nil { 2924 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 2925 } 2926 if v.Username == nil { 2927 invalidParams.Add(smithy.NewErrParamRequired("Username")) 2928 } 2929 if v.UserAttributeNames == nil { 2930 invalidParams.Add(smithy.NewErrParamRequired("UserAttributeNames")) 2931 } 2932 if invalidParams.Len() > 0 { 2933 return invalidParams 2934 } else { 2935 return nil 2936 } 2937} 2938 2939func validateOpAdminDeleteUserInput(v *AdminDeleteUserInput) error { 2940 if v == nil { 2941 return nil 2942 } 2943 invalidParams := smithy.InvalidParamsError{Context: "AdminDeleteUserInput"} 2944 if v.UserPoolId == nil { 2945 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 2946 } 2947 if v.Username == nil { 2948 invalidParams.Add(smithy.NewErrParamRequired("Username")) 2949 } 2950 if invalidParams.Len() > 0 { 2951 return invalidParams 2952 } else { 2953 return nil 2954 } 2955} 2956 2957func validateOpAdminDisableProviderForUserInput(v *AdminDisableProviderForUserInput) error { 2958 if v == nil { 2959 return nil 2960 } 2961 invalidParams := smithy.InvalidParamsError{Context: "AdminDisableProviderForUserInput"} 2962 if v.UserPoolId == nil { 2963 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 2964 } 2965 if v.User == nil { 2966 invalidParams.Add(smithy.NewErrParamRequired("User")) 2967 } 2968 if invalidParams.Len() > 0 { 2969 return invalidParams 2970 } else { 2971 return nil 2972 } 2973} 2974 2975func validateOpAdminDisableUserInput(v *AdminDisableUserInput) error { 2976 if v == nil { 2977 return nil 2978 } 2979 invalidParams := smithy.InvalidParamsError{Context: "AdminDisableUserInput"} 2980 if v.UserPoolId == nil { 2981 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 2982 } 2983 if v.Username == nil { 2984 invalidParams.Add(smithy.NewErrParamRequired("Username")) 2985 } 2986 if invalidParams.Len() > 0 { 2987 return invalidParams 2988 } else { 2989 return nil 2990 } 2991} 2992 2993func validateOpAdminEnableUserInput(v *AdminEnableUserInput) error { 2994 if v == nil { 2995 return nil 2996 } 2997 invalidParams := smithy.InvalidParamsError{Context: "AdminEnableUserInput"} 2998 if v.UserPoolId == nil { 2999 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3000 } 3001 if v.Username == nil { 3002 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3003 } 3004 if invalidParams.Len() > 0 { 3005 return invalidParams 3006 } else { 3007 return nil 3008 } 3009} 3010 3011func validateOpAdminForgetDeviceInput(v *AdminForgetDeviceInput) error { 3012 if v == nil { 3013 return nil 3014 } 3015 invalidParams := smithy.InvalidParamsError{Context: "AdminForgetDeviceInput"} 3016 if v.UserPoolId == nil { 3017 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3018 } 3019 if v.Username == nil { 3020 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3021 } 3022 if v.DeviceKey == nil { 3023 invalidParams.Add(smithy.NewErrParamRequired("DeviceKey")) 3024 } 3025 if invalidParams.Len() > 0 { 3026 return invalidParams 3027 } else { 3028 return nil 3029 } 3030} 3031 3032func validateOpAdminGetDeviceInput(v *AdminGetDeviceInput) error { 3033 if v == nil { 3034 return nil 3035 } 3036 invalidParams := smithy.InvalidParamsError{Context: "AdminGetDeviceInput"} 3037 if v.DeviceKey == nil { 3038 invalidParams.Add(smithy.NewErrParamRequired("DeviceKey")) 3039 } 3040 if v.UserPoolId == nil { 3041 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3042 } 3043 if v.Username == nil { 3044 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3045 } 3046 if invalidParams.Len() > 0 { 3047 return invalidParams 3048 } else { 3049 return nil 3050 } 3051} 3052 3053func validateOpAdminGetUserInput(v *AdminGetUserInput) error { 3054 if v == nil { 3055 return nil 3056 } 3057 invalidParams := smithy.InvalidParamsError{Context: "AdminGetUserInput"} 3058 if v.UserPoolId == nil { 3059 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3060 } 3061 if v.Username == nil { 3062 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3063 } 3064 if invalidParams.Len() > 0 { 3065 return invalidParams 3066 } else { 3067 return nil 3068 } 3069} 3070 3071func validateOpAdminInitiateAuthInput(v *AdminInitiateAuthInput) error { 3072 if v == nil { 3073 return nil 3074 } 3075 invalidParams := smithy.InvalidParamsError{Context: "AdminInitiateAuthInput"} 3076 if v.UserPoolId == nil { 3077 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3078 } 3079 if v.ClientId == nil { 3080 invalidParams.Add(smithy.NewErrParamRequired("ClientId")) 3081 } 3082 if len(v.AuthFlow) == 0 { 3083 invalidParams.Add(smithy.NewErrParamRequired("AuthFlow")) 3084 } 3085 if v.ContextData != nil { 3086 if err := validateContextDataType(v.ContextData); err != nil { 3087 invalidParams.AddNested("ContextData", err.(smithy.InvalidParamsError)) 3088 } 3089 } 3090 if invalidParams.Len() > 0 { 3091 return invalidParams 3092 } else { 3093 return nil 3094 } 3095} 3096 3097func validateOpAdminLinkProviderForUserInput(v *AdminLinkProviderForUserInput) error { 3098 if v == nil { 3099 return nil 3100 } 3101 invalidParams := smithy.InvalidParamsError{Context: "AdminLinkProviderForUserInput"} 3102 if v.UserPoolId == nil { 3103 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3104 } 3105 if v.DestinationUser == nil { 3106 invalidParams.Add(smithy.NewErrParamRequired("DestinationUser")) 3107 } 3108 if v.SourceUser == nil { 3109 invalidParams.Add(smithy.NewErrParamRequired("SourceUser")) 3110 } 3111 if invalidParams.Len() > 0 { 3112 return invalidParams 3113 } else { 3114 return nil 3115 } 3116} 3117 3118func validateOpAdminListDevicesInput(v *AdminListDevicesInput) error { 3119 if v == nil { 3120 return nil 3121 } 3122 invalidParams := smithy.InvalidParamsError{Context: "AdminListDevicesInput"} 3123 if v.UserPoolId == nil { 3124 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3125 } 3126 if v.Username == nil { 3127 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3128 } 3129 if invalidParams.Len() > 0 { 3130 return invalidParams 3131 } else { 3132 return nil 3133 } 3134} 3135 3136func validateOpAdminListGroupsForUserInput(v *AdminListGroupsForUserInput) error { 3137 if v == nil { 3138 return nil 3139 } 3140 invalidParams := smithy.InvalidParamsError{Context: "AdminListGroupsForUserInput"} 3141 if v.Username == nil { 3142 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3143 } 3144 if v.UserPoolId == nil { 3145 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3146 } 3147 if invalidParams.Len() > 0 { 3148 return invalidParams 3149 } else { 3150 return nil 3151 } 3152} 3153 3154func validateOpAdminListUserAuthEventsInput(v *AdminListUserAuthEventsInput) error { 3155 if v == nil { 3156 return nil 3157 } 3158 invalidParams := smithy.InvalidParamsError{Context: "AdminListUserAuthEventsInput"} 3159 if v.UserPoolId == nil { 3160 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3161 } 3162 if v.Username == nil { 3163 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3164 } 3165 if invalidParams.Len() > 0 { 3166 return invalidParams 3167 } else { 3168 return nil 3169 } 3170} 3171 3172func validateOpAdminRemoveUserFromGroupInput(v *AdminRemoveUserFromGroupInput) error { 3173 if v == nil { 3174 return nil 3175 } 3176 invalidParams := smithy.InvalidParamsError{Context: "AdminRemoveUserFromGroupInput"} 3177 if v.UserPoolId == nil { 3178 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3179 } 3180 if v.Username == nil { 3181 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3182 } 3183 if v.GroupName == nil { 3184 invalidParams.Add(smithy.NewErrParamRequired("GroupName")) 3185 } 3186 if invalidParams.Len() > 0 { 3187 return invalidParams 3188 } else { 3189 return nil 3190 } 3191} 3192 3193func validateOpAdminResetUserPasswordInput(v *AdminResetUserPasswordInput) error { 3194 if v == nil { 3195 return nil 3196 } 3197 invalidParams := smithy.InvalidParamsError{Context: "AdminResetUserPasswordInput"} 3198 if v.UserPoolId == nil { 3199 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3200 } 3201 if v.Username == nil { 3202 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3203 } 3204 if invalidParams.Len() > 0 { 3205 return invalidParams 3206 } else { 3207 return nil 3208 } 3209} 3210 3211func validateOpAdminRespondToAuthChallengeInput(v *AdminRespondToAuthChallengeInput) error { 3212 if v == nil { 3213 return nil 3214 } 3215 invalidParams := smithy.InvalidParamsError{Context: "AdminRespondToAuthChallengeInput"} 3216 if v.UserPoolId == nil { 3217 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3218 } 3219 if v.ClientId == nil { 3220 invalidParams.Add(smithy.NewErrParamRequired("ClientId")) 3221 } 3222 if len(v.ChallengeName) == 0 { 3223 invalidParams.Add(smithy.NewErrParamRequired("ChallengeName")) 3224 } 3225 if v.ContextData != nil { 3226 if err := validateContextDataType(v.ContextData); err != nil { 3227 invalidParams.AddNested("ContextData", err.(smithy.InvalidParamsError)) 3228 } 3229 } 3230 if invalidParams.Len() > 0 { 3231 return invalidParams 3232 } else { 3233 return nil 3234 } 3235} 3236 3237func validateOpAdminSetUserMFAPreferenceInput(v *AdminSetUserMFAPreferenceInput) error { 3238 if v == nil { 3239 return nil 3240 } 3241 invalidParams := smithy.InvalidParamsError{Context: "AdminSetUserMFAPreferenceInput"} 3242 if v.Username == nil { 3243 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3244 } 3245 if v.UserPoolId == nil { 3246 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3247 } 3248 if invalidParams.Len() > 0 { 3249 return invalidParams 3250 } else { 3251 return nil 3252 } 3253} 3254 3255func validateOpAdminSetUserPasswordInput(v *AdminSetUserPasswordInput) error { 3256 if v == nil { 3257 return nil 3258 } 3259 invalidParams := smithy.InvalidParamsError{Context: "AdminSetUserPasswordInput"} 3260 if v.UserPoolId == nil { 3261 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3262 } 3263 if v.Username == nil { 3264 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3265 } 3266 if v.Password == nil { 3267 invalidParams.Add(smithy.NewErrParamRequired("Password")) 3268 } 3269 if invalidParams.Len() > 0 { 3270 return invalidParams 3271 } else { 3272 return nil 3273 } 3274} 3275 3276func validateOpAdminSetUserSettingsInput(v *AdminSetUserSettingsInput) error { 3277 if v == nil { 3278 return nil 3279 } 3280 invalidParams := smithy.InvalidParamsError{Context: "AdminSetUserSettingsInput"} 3281 if v.UserPoolId == nil { 3282 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3283 } 3284 if v.Username == nil { 3285 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3286 } 3287 if v.MFAOptions == nil { 3288 invalidParams.Add(smithy.NewErrParamRequired("MFAOptions")) 3289 } 3290 if invalidParams.Len() > 0 { 3291 return invalidParams 3292 } else { 3293 return nil 3294 } 3295} 3296 3297func validateOpAdminUpdateAuthEventFeedbackInput(v *AdminUpdateAuthEventFeedbackInput) error { 3298 if v == nil { 3299 return nil 3300 } 3301 invalidParams := smithy.InvalidParamsError{Context: "AdminUpdateAuthEventFeedbackInput"} 3302 if v.UserPoolId == nil { 3303 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3304 } 3305 if v.Username == nil { 3306 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3307 } 3308 if v.EventId == nil { 3309 invalidParams.Add(smithy.NewErrParamRequired("EventId")) 3310 } 3311 if len(v.FeedbackValue) == 0 { 3312 invalidParams.Add(smithy.NewErrParamRequired("FeedbackValue")) 3313 } 3314 if invalidParams.Len() > 0 { 3315 return invalidParams 3316 } else { 3317 return nil 3318 } 3319} 3320 3321func validateOpAdminUpdateDeviceStatusInput(v *AdminUpdateDeviceStatusInput) error { 3322 if v == nil { 3323 return nil 3324 } 3325 invalidParams := smithy.InvalidParamsError{Context: "AdminUpdateDeviceStatusInput"} 3326 if v.UserPoolId == nil { 3327 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3328 } 3329 if v.Username == nil { 3330 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3331 } 3332 if v.DeviceKey == nil { 3333 invalidParams.Add(smithy.NewErrParamRequired("DeviceKey")) 3334 } 3335 if invalidParams.Len() > 0 { 3336 return invalidParams 3337 } else { 3338 return nil 3339 } 3340} 3341 3342func validateOpAdminUpdateUserAttributesInput(v *AdminUpdateUserAttributesInput) error { 3343 if v == nil { 3344 return nil 3345 } 3346 invalidParams := smithy.InvalidParamsError{Context: "AdminUpdateUserAttributesInput"} 3347 if v.UserPoolId == nil { 3348 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3349 } 3350 if v.Username == nil { 3351 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3352 } 3353 if v.UserAttributes == nil { 3354 invalidParams.Add(smithy.NewErrParamRequired("UserAttributes")) 3355 } else if v.UserAttributes != nil { 3356 if err := validateAttributeListType(v.UserAttributes); err != nil { 3357 invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError)) 3358 } 3359 } 3360 if invalidParams.Len() > 0 { 3361 return invalidParams 3362 } else { 3363 return nil 3364 } 3365} 3366 3367func validateOpAdminUserGlobalSignOutInput(v *AdminUserGlobalSignOutInput) error { 3368 if v == nil { 3369 return nil 3370 } 3371 invalidParams := smithy.InvalidParamsError{Context: "AdminUserGlobalSignOutInput"} 3372 if v.UserPoolId == nil { 3373 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3374 } 3375 if v.Username == nil { 3376 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3377 } 3378 if invalidParams.Len() > 0 { 3379 return invalidParams 3380 } else { 3381 return nil 3382 } 3383} 3384 3385func validateOpChangePasswordInput(v *ChangePasswordInput) error { 3386 if v == nil { 3387 return nil 3388 } 3389 invalidParams := smithy.InvalidParamsError{Context: "ChangePasswordInput"} 3390 if v.PreviousPassword == nil { 3391 invalidParams.Add(smithy.NewErrParamRequired("PreviousPassword")) 3392 } 3393 if v.ProposedPassword == nil { 3394 invalidParams.Add(smithy.NewErrParamRequired("ProposedPassword")) 3395 } 3396 if v.AccessToken == nil { 3397 invalidParams.Add(smithy.NewErrParamRequired("AccessToken")) 3398 } 3399 if invalidParams.Len() > 0 { 3400 return invalidParams 3401 } else { 3402 return nil 3403 } 3404} 3405 3406func validateOpConfirmDeviceInput(v *ConfirmDeviceInput) error { 3407 if v == nil { 3408 return nil 3409 } 3410 invalidParams := smithy.InvalidParamsError{Context: "ConfirmDeviceInput"} 3411 if v.AccessToken == nil { 3412 invalidParams.Add(smithy.NewErrParamRequired("AccessToken")) 3413 } 3414 if v.DeviceKey == nil { 3415 invalidParams.Add(smithy.NewErrParamRequired("DeviceKey")) 3416 } 3417 if invalidParams.Len() > 0 { 3418 return invalidParams 3419 } else { 3420 return nil 3421 } 3422} 3423 3424func validateOpConfirmForgotPasswordInput(v *ConfirmForgotPasswordInput) error { 3425 if v == nil { 3426 return nil 3427 } 3428 invalidParams := smithy.InvalidParamsError{Context: "ConfirmForgotPasswordInput"} 3429 if v.ClientId == nil { 3430 invalidParams.Add(smithy.NewErrParamRequired("ClientId")) 3431 } 3432 if v.Username == nil { 3433 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3434 } 3435 if v.ConfirmationCode == nil { 3436 invalidParams.Add(smithy.NewErrParamRequired("ConfirmationCode")) 3437 } 3438 if v.Password == nil { 3439 invalidParams.Add(smithy.NewErrParamRequired("Password")) 3440 } 3441 if invalidParams.Len() > 0 { 3442 return invalidParams 3443 } else { 3444 return nil 3445 } 3446} 3447 3448func validateOpConfirmSignUpInput(v *ConfirmSignUpInput) error { 3449 if v == nil { 3450 return nil 3451 } 3452 invalidParams := smithy.InvalidParamsError{Context: "ConfirmSignUpInput"} 3453 if v.ClientId == nil { 3454 invalidParams.Add(smithy.NewErrParamRequired("ClientId")) 3455 } 3456 if v.Username == nil { 3457 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3458 } 3459 if v.ConfirmationCode == nil { 3460 invalidParams.Add(smithy.NewErrParamRequired("ConfirmationCode")) 3461 } 3462 if invalidParams.Len() > 0 { 3463 return invalidParams 3464 } else { 3465 return nil 3466 } 3467} 3468 3469func validateOpCreateGroupInput(v *CreateGroupInput) error { 3470 if v == nil { 3471 return nil 3472 } 3473 invalidParams := smithy.InvalidParamsError{Context: "CreateGroupInput"} 3474 if v.GroupName == nil { 3475 invalidParams.Add(smithy.NewErrParamRequired("GroupName")) 3476 } 3477 if v.UserPoolId == nil { 3478 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3479 } 3480 if invalidParams.Len() > 0 { 3481 return invalidParams 3482 } else { 3483 return nil 3484 } 3485} 3486 3487func validateOpCreateIdentityProviderInput(v *CreateIdentityProviderInput) error { 3488 if v == nil { 3489 return nil 3490 } 3491 invalidParams := smithy.InvalidParamsError{Context: "CreateIdentityProviderInput"} 3492 if v.UserPoolId == nil { 3493 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3494 } 3495 if v.ProviderName == nil { 3496 invalidParams.Add(smithy.NewErrParamRequired("ProviderName")) 3497 } 3498 if len(v.ProviderType) == 0 { 3499 invalidParams.Add(smithy.NewErrParamRequired("ProviderType")) 3500 } 3501 if v.ProviderDetails == nil { 3502 invalidParams.Add(smithy.NewErrParamRequired("ProviderDetails")) 3503 } 3504 if invalidParams.Len() > 0 { 3505 return invalidParams 3506 } else { 3507 return nil 3508 } 3509} 3510 3511func validateOpCreateResourceServerInput(v *CreateResourceServerInput) error { 3512 if v == nil { 3513 return nil 3514 } 3515 invalidParams := smithy.InvalidParamsError{Context: "CreateResourceServerInput"} 3516 if v.UserPoolId == nil { 3517 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3518 } 3519 if v.Identifier == nil { 3520 invalidParams.Add(smithy.NewErrParamRequired("Identifier")) 3521 } 3522 if v.Name == nil { 3523 invalidParams.Add(smithy.NewErrParamRequired("Name")) 3524 } 3525 if v.Scopes != nil { 3526 if err := validateResourceServerScopeListType(v.Scopes); err != nil { 3527 invalidParams.AddNested("Scopes", err.(smithy.InvalidParamsError)) 3528 } 3529 } 3530 if invalidParams.Len() > 0 { 3531 return invalidParams 3532 } else { 3533 return nil 3534 } 3535} 3536 3537func validateOpCreateUserImportJobInput(v *CreateUserImportJobInput) error { 3538 if v == nil { 3539 return nil 3540 } 3541 invalidParams := smithy.InvalidParamsError{Context: "CreateUserImportJobInput"} 3542 if v.JobName == nil { 3543 invalidParams.Add(smithy.NewErrParamRequired("JobName")) 3544 } 3545 if v.UserPoolId == nil { 3546 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3547 } 3548 if v.CloudWatchLogsRoleArn == nil { 3549 invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLogsRoleArn")) 3550 } 3551 if invalidParams.Len() > 0 { 3552 return invalidParams 3553 } else { 3554 return nil 3555 } 3556} 3557 3558func validateOpCreateUserPoolClientInput(v *CreateUserPoolClientInput) error { 3559 if v == nil { 3560 return nil 3561 } 3562 invalidParams := smithy.InvalidParamsError{Context: "CreateUserPoolClientInput"} 3563 if v.UserPoolId == nil { 3564 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3565 } 3566 if v.ClientName == nil { 3567 invalidParams.Add(smithy.NewErrParamRequired("ClientName")) 3568 } 3569 if invalidParams.Len() > 0 { 3570 return invalidParams 3571 } else { 3572 return nil 3573 } 3574} 3575 3576func validateOpCreateUserPoolDomainInput(v *CreateUserPoolDomainInput) error { 3577 if v == nil { 3578 return nil 3579 } 3580 invalidParams := smithy.InvalidParamsError{Context: "CreateUserPoolDomainInput"} 3581 if v.Domain == nil { 3582 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 3583 } 3584 if v.UserPoolId == nil { 3585 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3586 } 3587 if v.CustomDomainConfig != nil { 3588 if err := validateCustomDomainConfigType(v.CustomDomainConfig); err != nil { 3589 invalidParams.AddNested("CustomDomainConfig", err.(smithy.InvalidParamsError)) 3590 } 3591 } 3592 if invalidParams.Len() > 0 { 3593 return invalidParams 3594 } else { 3595 return nil 3596 } 3597} 3598 3599func validateOpCreateUserPoolInput(v *CreateUserPoolInput) error { 3600 if v == nil { 3601 return nil 3602 } 3603 invalidParams := smithy.InvalidParamsError{Context: "CreateUserPoolInput"} 3604 if v.PoolName == nil { 3605 invalidParams.Add(smithy.NewErrParamRequired("PoolName")) 3606 } 3607 if v.LambdaConfig != nil { 3608 if err := validateLambdaConfigType(v.LambdaConfig); err != nil { 3609 invalidParams.AddNested("LambdaConfig", err.(smithy.InvalidParamsError)) 3610 } 3611 } 3612 if v.SmsConfiguration != nil { 3613 if err := validateSmsConfigurationType(v.SmsConfiguration); err != nil { 3614 invalidParams.AddNested("SmsConfiguration", err.(smithy.InvalidParamsError)) 3615 } 3616 } 3617 if v.UserPoolAddOns != nil { 3618 if err := validateUserPoolAddOnsType(v.UserPoolAddOns); err != nil { 3619 invalidParams.AddNested("UserPoolAddOns", err.(smithy.InvalidParamsError)) 3620 } 3621 } 3622 if v.UsernameConfiguration != nil { 3623 if err := validateUsernameConfigurationType(v.UsernameConfiguration); err != nil { 3624 invalidParams.AddNested("UsernameConfiguration", err.(smithy.InvalidParamsError)) 3625 } 3626 } 3627 if v.AccountRecoverySetting != nil { 3628 if err := validateAccountRecoverySettingType(v.AccountRecoverySetting); err != nil { 3629 invalidParams.AddNested("AccountRecoverySetting", err.(smithy.InvalidParamsError)) 3630 } 3631 } 3632 if invalidParams.Len() > 0 { 3633 return invalidParams 3634 } else { 3635 return nil 3636 } 3637} 3638 3639func validateOpDeleteGroupInput(v *DeleteGroupInput) error { 3640 if v == nil { 3641 return nil 3642 } 3643 invalidParams := smithy.InvalidParamsError{Context: "DeleteGroupInput"} 3644 if v.GroupName == nil { 3645 invalidParams.Add(smithy.NewErrParamRequired("GroupName")) 3646 } 3647 if v.UserPoolId == nil { 3648 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3649 } 3650 if invalidParams.Len() > 0 { 3651 return invalidParams 3652 } else { 3653 return nil 3654 } 3655} 3656 3657func validateOpDeleteIdentityProviderInput(v *DeleteIdentityProviderInput) error { 3658 if v == nil { 3659 return nil 3660 } 3661 invalidParams := smithy.InvalidParamsError{Context: "DeleteIdentityProviderInput"} 3662 if v.UserPoolId == nil { 3663 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3664 } 3665 if v.ProviderName == nil { 3666 invalidParams.Add(smithy.NewErrParamRequired("ProviderName")) 3667 } 3668 if invalidParams.Len() > 0 { 3669 return invalidParams 3670 } else { 3671 return nil 3672 } 3673} 3674 3675func validateOpDeleteResourceServerInput(v *DeleteResourceServerInput) error { 3676 if v == nil { 3677 return nil 3678 } 3679 invalidParams := smithy.InvalidParamsError{Context: "DeleteResourceServerInput"} 3680 if v.UserPoolId == nil { 3681 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3682 } 3683 if v.Identifier == nil { 3684 invalidParams.Add(smithy.NewErrParamRequired("Identifier")) 3685 } 3686 if invalidParams.Len() > 0 { 3687 return invalidParams 3688 } else { 3689 return nil 3690 } 3691} 3692 3693func validateOpDeleteUserAttributesInput(v *DeleteUserAttributesInput) error { 3694 if v == nil { 3695 return nil 3696 } 3697 invalidParams := smithy.InvalidParamsError{Context: "DeleteUserAttributesInput"} 3698 if v.UserAttributeNames == nil { 3699 invalidParams.Add(smithy.NewErrParamRequired("UserAttributeNames")) 3700 } 3701 if v.AccessToken == nil { 3702 invalidParams.Add(smithy.NewErrParamRequired("AccessToken")) 3703 } 3704 if invalidParams.Len() > 0 { 3705 return invalidParams 3706 } else { 3707 return nil 3708 } 3709} 3710 3711func validateOpDeleteUserInput(v *DeleteUserInput) error { 3712 if v == nil { 3713 return nil 3714 } 3715 invalidParams := smithy.InvalidParamsError{Context: "DeleteUserInput"} 3716 if v.AccessToken == nil { 3717 invalidParams.Add(smithy.NewErrParamRequired("AccessToken")) 3718 } 3719 if invalidParams.Len() > 0 { 3720 return invalidParams 3721 } else { 3722 return nil 3723 } 3724} 3725 3726func validateOpDeleteUserPoolClientInput(v *DeleteUserPoolClientInput) error { 3727 if v == nil { 3728 return nil 3729 } 3730 invalidParams := smithy.InvalidParamsError{Context: "DeleteUserPoolClientInput"} 3731 if v.UserPoolId == nil { 3732 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3733 } 3734 if v.ClientId == nil { 3735 invalidParams.Add(smithy.NewErrParamRequired("ClientId")) 3736 } 3737 if invalidParams.Len() > 0 { 3738 return invalidParams 3739 } else { 3740 return nil 3741 } 3742} 3743 3744func validateOpDeleteUserPoolDomainInput(v *DeleteUserPoolDomainInput) error { 3745 if v == nil { 3746 return nil 3747 } 3748 invalidParams := smithy.InvalidParamsError{Context: "DeleteUserPoolDomainInput"} 3749 if v.Domain == nil { 3750 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 3751 } 3752 if v.UserPoolId == nil { 3753 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3754 } 3755 if invalidParams.Len() > 0 { 3756 return invalidParams 3757 } else { 3758 return nil 3759 } 3760} 3761 3762func validateOpDeleteUserPoolInput(v *DeleteUserPoolInput) error { 3763 if v == nil { 3764 return nil 3765 } 3766 invalidParams := smithy.InvalidParamsError{Context: "DeleteUserPoolInput"} 3767 if v.UserPoolId == nil { 3768 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3769 } 3770 if invalidParams.Len() > 0 { 3771 return invalidParams 3772 } else { 3773 return nil 3774 } 3775} 3776 3777func validateOpDescribeIdentityProviderInput(v *DescribeIdentityProviderInput) error { 3778 if v == nil { 3779 return nil 3780 } 3781 invalidParams := smithy.InvalidParamsError{Context: "DescribeIdentityProviderInput"} 3782 if v.UserPoolId == nil { 3783 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3784 } 3785 if v.ProviderName == nil { 3786 invalidParams.Add(smithy.NewErrParamRequired("ProviderName")) 3787 } 3788 if invalidParams.Len() > 0 { 3789 return invalidParams 3790 } else { 3791 return nil 3792 } 3793} 3794 3795func validateOpDescribeResourceServerInput(v *DescribeResourceServerInput) error { 3796 if v == nil { 3797 return nil 3798 } 3799 invalidParams := smithy.InvalidParamsError{Context: "DescribeResourceServerInput"} 3800 if v.UserPoolId == nil { 3801 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3802 } 3803 if v.Identifier == nil { 3804 invalidParams.Add(smithy.NewErrParamRequired("Identifier")) 3805 } 3806 if invalidParams.Len() > 0 { 3807 return invalidParams 3808 } else { 3809 return nil 3810 } 3811} 3812 3813func validateOpDescribeRiskConfigurationInput(v *DescribeRiskConfigurationInput) error { 3814 if v == nil { 3815 return nil 3816 } 3817 invalidParams := smithy.InvalidParamsError{Context: "DescribeRiskConfigurationInput"} 3818 if v.UserPoolId == nil { 3819 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3820 } 3821 if invalidParams.Len() > 0 { 3822 return invalidParams 3823 } else { 3824 return nil 3825 } 3826} 3827 3828func validateOpDescribeUserImportJobInput(v *DescribeUserImportJobInput) error { 3829 if v == nil { 3830 return nil 3831 } 3832 invalidParams := smithy.InvalidParamsError{Context: "DescribeUserImportJobInput"} 3833 if v.UserPoolId == nil { 3834 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3835 } 3836 if v.JobId == nil { 3837 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 3838 } 3839 if invalidParams.Len() > 0 { 3840 return invalidParams 3841 } else { 3842 return nil 3843 } 3844} 3845 3846func validateOpDescribeUserPoolClientInput(v *DescribeUserPoolClientInput) error { 3847 if v == nil { 3848 return nil 3849 } 3850 invalidParams := smithy.InvalidParamsError{Context: "DescribeUserPoolClientInput"} 3851 if v.UserPoolId == nil { 3852 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3853 } 3854 if v.ClientId == nil { 3855 invalidParams.Add(smithy.NewErrParamRequired("ClientId")) 3856 } 3857 if invalidParams.Len() > 0 { 3858 return invalidParams 3859 } else { 3860 return nil 3861 } 3862} 3863 3864func validateOpDescribeUserPoolDomainInput(v *DescribeUserPoolDomainInput) error { 3865 if v == nil { 3866 return nil 3867 } 3868 invalidParams := smithy.InvalidParamsError{Context: "DescribeUserPoolDomainInput"} 3869 if v.Domain == nil { 3870 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 3871 } 3872 if invalidParams.Len() > 0 { 3873 return invalidParams 3874 } else { 3875 return nil 3876 } 3877} 3878 3879func validateOpDescribeUserPoolInput(v *DescribeUserPoolInput) error { 3880 if v == nil { 3881 return nil 3882 } 3883 invalidParams := smithy.InvalidParamsError{Context: "DescribeUserPoolInput"} 3884 if v.UserPoolId == nil { 3885 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3886 } 3887 if invalidParams.Len() > 0 { 3888 return invalidParams 3889 } else { 3890 return nil 3891 } 3892} 3893 3894func validateOpForgetDeviceInput(v *ForgetDeviceInput) error { 3895 if v == nil { 3896 return nil 3897 } 3898 invalidParams := smithy.InvalidParamsError{Context: "ForgetDeviceInput"} 3899 if v.DeviceKey == nil { 3900 invalidParams.Add(smithy.NewErrParamRequired("DeviceKey")) 3901 } 3902 if invalidParams.Len() > 0 { 3903 return invalidParams 3904 } else { 3905 return nil 3906 } 3907} 3908 3909func validateOpForgotPasswordInput(v *ForgotPasswordInput) error { 3910 if v == nil { 3911 return nil 3912 } 3913 invalidParams := smithy.InvalidParamsError{Context: "ForgotPasswordInput"} 3914 if v.ClientId == nil { 3915 invalidParams.Add(smithy.NewErrParamRequired("ClientId")) 3916 } 3917 if v.Username == nil { 3918 invalidParams.Add(smithy.NewErrParamRequired("Username")) 3919 } 3920 if invalidParams.Len() > 0 { 3921 return invalidParams 3922 } else { 3923 return nil 3924 } 3925} 3926 3927func validateOpGetCSVHeaderInput(v *GetCSVHeaderInput) error { 3928 if v == nil { 3929 return nil 3930 } 3931 invalidParams := smithy.InvalidParamsError{Context: "GetCSVHeaderInput"} 3932 if v.UserPoolId == nil { 3933 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3934 } 3935 if invalidParams.Len() > 0 { 3936 return invalidParams 3937 } else { 3938 return nil 3939 } 3940} 3941 3942func validateOpGetDeviceInput(v *GetDeviceInput) error { 3943 if v == nil { 3944 return nil 3945 } 3946 invalidParams := smithy.InvalidParamsError{Context: "GetDeviceInput"} 3947 if v.DeviceKey == nil { 3948 invalidParams.Add(smithy.NewErrParamRequired("DeviceKey")) 3949 } 3950 if invalidParams.Len() > 0 { 3951 return invalidParams 3952 } else { 3953 return nil 3954 } 3955} 3956 3957func validateOpGetGroupInput(v *GetGroupInput) error { 3958 if v == nil { 3959 return nil 3960 } 3961 invalidParams := smithy.InvalidParamsError{Context: "GetGroupInput"} 3962 if v.GroupName == nil { 3963 invalidParams.Add(smithy.NewErrParamRequired("GroupName")) 3964 } 3965 if v.UserPoolId == nil { 3966 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3967 } 3968 if invalidParams.Len() > 0 { 3969 return invalidParams 3970 } else { 3971 return nil 3972 } 3973} 3974 3975func validateOpGetIdentityProviderByIdentifierInput(v *GetIdentityProviderByIdentifierInput) error { 3976 if v == nil { 3977 return nil 3978 } 3979 invalidParams := smithy.InvalidParamsError{Context: "GetIdentityProviderByIdentifierInput"} 3980 if v.UserPoolId == nil { 3981 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 3982 } 3983 if v.IdpIdentifier == nil { 3984 invalidParams.Add(smithy.NewErrParamRequired("IdpIdentifier")) 3985 } 3986 if invalidParams.Len() > 0 { 3987 return invalidParams 3988 } else { 3989 return nil 3990 } 3991} 3992 3993func validateOpGetSigningCertificateInput(v *GetSigningCertificateInput) error { 3994 if v == nil { 3995 return nil 3996 } 3997 invalidParams := smithy.InvalidParamsError{Context: "GetSigningCertificateInput"} 3998 if v.UserPoolId == nil { 3999 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4000 } 4001 if invalidParams.Len() > 0 { 4002 return invalidParams 4003 } else { 4004 return nil 4005 } 4006} 4007 4008func validateOpGetUICustomizationInput(v *GetUICustomizationInput) error { 4009 if v == nil { 4010 return nil 4011 } 4012 invalidParams := smithy.InvalidParamsError{Context: "GetUICustomizationInput"} 4013 if v.UserPoolId == nil { 4014 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4015 } 4016 if invalidParams.Len() > 0 { 4017 return invalidParams 4018 } else { 4019 return nil 4020 } 4021} 4022 4023func validateOpGetUserAttributeVerificationCodeInput(v *GetUserAttributeVerificationCodeInput) error { 4024 if v == nil { 4025 return nil 4026 } 4027 invalidParams := smithy.InvalidParamsError{Context: "GetUserAttributeVerificationCodeInput"} 4028 if v.AccessToken == nil { 4029 invalidParams.Add(smithy.NewErrParamRequired("AccessToken")) 4030 } 4031 if v.AttributeName == nil { 4032 invalidParams.Add(smithy.NewErrParamRequired("AttributeName")) 4033 } 4034 if invalidParams.Len() > 0 { 4035 return invalidParams 4036 } else { 4037 return nil 4038 } 4039} 4040 4041func validateOpGetUserInput(v *GetUserInput) error { 4042 if v == nil { 4043 return nil 4044 } 4045 invalidParams := smithy.InvalidParamsError{Context: "GetUserInput"} 4046 if v.AccessToken == nil { 4047 invalidParams.Add(smithy.NewErrParamRequired("AccessToken")) 4048 } 4049 if invalidParams.Len() > 0 { 4050 return invalidParams 4051 } else { 4052 return nil 4053 } 4054} 4055 4056func validateOpGetUserPoolMfaConfigInput(v *GetUserPoolMfaConfigInput) error { 4057 if v == nil { 4058 return nil 4059 } 4060 invalidParams := smithy.InvalidParamsError{Context: "GetUserPoolMfaConfigInput"} 4061 if v.UserPoolId == nil { 4062 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4063 } 4064 if invalidParams.Len() > 0 { 4065 return invalidParams 4066 } else { 4067 return nil 4068 } 4069} 4070 4071func validateOpGlobalSignOutInput(v *GlobalSignOutInput) error { 4072 if v == nil { 4073 return nil 4074 } 4075 invalidParams := smithy.InvalidParamsError{Context: "GlobalSignOutInput"} 4076 if v.AccessToken == nil { 4077 invalidParams.Add(smithy.NewErrParamRequired("AccessToken")) 4078 } 4079 if invalidParams.Len() > 0 { 4080 return invalidParams 4081 } else { 4082 return nil 4083 } 4084} 4085 4086func validateOpInitiateAuthInput(v *InitiateAuthInput) error { 4087 if v == nil { 4088 return nil 4089 } 4090 invalidParams := smithy.InvalidParamsError{Context: "InitiateAuthInput"} 4091 if len(v.AuthFlow) == 0 { 4092 invalidParams.Add(smithy.NewErrParamRequired("AuthFlow")) 4093 } 4094 if v.ClientId == nil { 4095 invalidParams.Add(smithy.NewErrParamRequired("ClientId")) 4096 } 4097 if invalidParams.Len() > 0 { 4098 return invalidParams 4099 } else { 4100 return nil 4101 } 4102} 4103 4104func validateOpListDevicesInput(v *ListDevicesInput) error { 4105 if v == nil { 4106 return nil 4107 } 4108 invalidParams := smithy.InvalidParamsError{Context: "ListDevicesInput"} 4109 if v.AccessToken == nil { 4110 invalidParams.Add(smithy.NewErrParamRequired("AccessToken")) 4111 } 4112 if invalidParams.Len() > 0 { 4113 return invalidParams 4114 } else { 4115 return nil 4116 } 4117} 4118 4119func validateOpListGroupsInput(v *ListGroupsInput) error { 4120 if v == nil { 4121 return nil 4122 } 4123 invalidParams := smithy.InvalidParamsError{Context: "ListGroupsInput"} 4124 if v.UserPoolId == nil { 4125 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4126 } 4127 if invalidParams.Len() > 0 { 4128 return invalidParams 4129 } else { 4130 return nil 4131 } 4132} 4133 4134func validateOpListIdentityProvidersInput(v *ListIdentityProvidersInput) error { 4135 if v == nil { 4136 return nil 4137 } 4138 invalidParams := smithy.InvalidParamsError{Context: "ListIdentityProvidersInput"} 4139 if v.UserPoolId == nil { 4140 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4141 } 4142 if invalidParams.Len() > 0 { 4143 return invalidParams 4144 } else { 4145 return nil 4146 } 4147} 4148 4149func validateOpListResourceServersInput(v *ListResourceServersInput) error { 4150 if v == nil { 4151 return nil 4152 } 4153 invalidParams := smithy.InvalidParamsError{Context: "ListResourceServersInput"} 4154 if v.UserPoolId == nil { 4155 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4156 } 4157 if invalidParams.Len() > 0 { 4158 return invalidParams 4159 } else { 4160 return nil 4161 } 4162} 4163 4164func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error { 4165 if v == nil { 4166 return nil 4167 } 4168 invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"} 4169 if v.ResourceArn == nil { 4170 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 4171 } 4172 if invalidParams.Len() > 0 { 4173 return invalidParams 4174 } else { 4175 return nil 4176 } 4177} 4178 4179func validateOpListUserImportJobsInput(v *ListUserImportJobsInput) error { 4180 if v == nil { 4181 return nil 4182 } 4183 invalidParams := smithy.InvalidParamsError{Context: "ListUserImportJobsInput"} 4184 if v.UserPoolId == nil { 4185 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4186 } 4187 if invalidParams.Len() > 0 { 4188 return invalidParams 4189 } else { 4190 return nil 4191 } 4192} 4193 4194func validateOpListUserPoolClientsInput(v *ListUserPoolClientsInput) error { 4195 if v == nil { 4196 return nil 4197 } 4198 invalidParams := smithy.InvalidParamsError{Context: "ListUserPoolClientsInput"} 4199 if v.UserPoolId == nil { 4200 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4201 } 4202 if invalidParams.Len() > 0 { 4203 return invalidParams 4204 } else { 4205 return nil 4206 } 4207} 4208 4209func validateOpListUserPoolsInput(v *ListUserPoolsInput) error { 4210 if v == nil { 4211 return nil 4212 } 4213 invalidParams := smithy.InvalidParamsError{Context: "ListUserPoolsInput"} 4214 if invalidParams.Len() > 0 { 4215 return invalidParams 4216 } else { 4217 return nil 4218 } 4219} 4220 4221func validateOpListUsersInGroupInput(v *ListUsersInGroupInput) error { 4222 if v == nil { 4223 return nil 4224 } 4225 invalidParams := smithy.InvalidParamsError{Context: "ListUsersInGroupInput"} 4226 if v.UserPoolId == nil { 4227 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4228 } 4229 if v.GroupName == nil { 4230 invalidParams.Add(smithy.NewErrParamRequired("GroupName")) 4231 } 4232 if invalidParams.Len() > 0 { 4233 return invalidParams 4234 } else { 4235 return nil 4236 } 4237} 4238 4239func validateOpListUsersInput(v *ListUsersInput) error { 4240 if v == nil { 4241 return nil 4242 } 4243 invalidParams := smithy.InvalidParamsError{Context: "ListUsersInput"} 4244 if v.UserPoolId == nil { 4245 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4246 } 4247 if invalidParams.Len() > 0 { 4248 return invalidParams 4249 } else { 4250 return nil 4251 } 4252} 4253 4254func validateOpResendConfirmationCodeInput(v *ResendConfirmationCodeInput) error { 4255 if v == nil { 4256 return nil 4257 } 4258 invalidParams := smithy.InvalidParamsError{Context: "ResendConfirmationCodeInput"} 4259 if v.ClientId == nil { 4260 invalidParams.Add(smithy.NewErrParamRequired("ClientId")) 4261 } 4262 if v.Username == nil { 4263 invalidParams.Add(smithy.NewErrParamRequired("Username")) 4264 } 4265 if invalidParams.Len() > 0 { 4266 return invalidParams 4267 } else { 4268 return nil 4269 } 4270} 4271 4272func validateOpRespondToAuthChallengeInput(v *RespondToAuthChallengeInput) error { 4273 if v == nil { 4274 return nil 4275 } 4276 invalidParams := smithy.InvalidParamsError{Context: "RespondToAuthChallengeInput"} 4277 if v.ClientId == nil { 4278 invalidParams.Add(smithy.NewErrParamRequired("ClientId")) 4279 } 4280 if len(v.ChallengeName) == 0 { 4281 invalidParams.Add(smithy.NewErrParamRequired("ChallengeName")) 4282 } 4283 if invalidParams.Len() > 0 { 4284 return invalidParams 4285 } else { 4286 return nil 4287 } 4288} 4289 4290func validateOpRevokeTokenInput(v *RevokeTokenInput) error { 4291 if v == nil { 4292 return nil 4293 } 4294 invalidParams := smithy.InvalidParamsError{Context: "RevokeTokenInput"} 4295 if v.Token == nil { 4296 invalidParams.Add(smithy.NewErrParamRequired("Token")) 4297 } 4298 if v.ClientId == nil { 4299 invalidParams.Add(smithy.NewErrParamRequired("ClientId")) 4300 } 4301 if invalidParams.Len() > 0 { 4302 return invalidParams 4303 } else { 4304 return nil 4305 } 4306} 4307 4308func validateOpSetRiskConfigurationInput(v *SetRiskConfigurationInput) error { 4309 if v == nil { 4310 return nil 4311 } 4312 invalidParams := smithy.InvalidParamsError{Context: "SetRiskConfigurationInput"} 4313 if v.UserPoolId == nil { 4314 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4315 } 4316 if v.CompromisedCredentialsRiskConfiguration != nil { 4317 if err := validateCompromisedCredentialsRiskConfigurationType(v.CompromisedCredentialsRiskConfiguration); err != nil { 4318 invalidParams.AddNested("CompromisedCredentialsRiskConfiguration", err.(smithy.InvalidParamsError)) 4319 } 4320 } 4321 if v.AccountTakeoverRiskConfiguration != nil { 4322 if err := validateAccountTakeoverRiskConfigurationType(v.AccountTakeoverRiskConfiguration); err != nil { 4323 invalidParams.AddNested("AccountTakeoverRiskConfiguration", err.(smithy.InvalidParamsError)) 4324 } 4325 } 4326 if invalidParams.Len() > 0 { 4327 return invalidParams 4328 } else { 4329 return nil 4330 } 4331} 4332 4333func validateOpSetUICustomizationInput(v *SetUICustomizationInput) error { 4334 if v == nil { 4335 return nil 4336 } 4337 invalidParams := smithy.InvalidParamsError{Context: "SetUICustomizationInput"} 4338 if v.UserPoolId == nil { 4339 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4340 } 4341 if invalidParams.Len() > 0 { 4342 return invalidParams 4343 } else { 4344 return nil 4345 } 4346} 4347 4348func validateOpSetUserMFAPreferenceInput(v *SetUserMFAPreferenceInput) error { 4349 if v == nil { 4350 return nil 4351 } 4352 invalidParams := smithy.InvalidParamsError{Context: "SetUserMFAPreferenceInput"} 4353 if v.AccessToken == nil { 4354 invalidParams.Add(smithy.NewErrParamRequired("AccessToken")) 4355 } 4356 if invalidParams.Len() > 0 { 4357 return invalidParams 4358 } else { 4359 return nil 4360 } 4361} 4362 4363func validateOpSetUserPoolMfaConfigInput(v *SetUserPoolMfaConfigInput) error { 4364 if v == nil { 4365 return nil 4366 } 4367 invalidParams := smithy.InvalidParamsError{Context: "SetUserPoolMfaConfigInput"} 4368 if v.UserPoolId == nil { 4369 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4370 } 4371 if v.SmsMfaConfiguration != nil { 4372 if err := validateSmsMfaConfigType(v.SmsMfaConfiguration); err != nil { 4373 invalidParams.AddNested("SmsMfaConfiguration", err.(smithy.InvalidParamsError)) 4374 } 4375 } 4376 if invalidParams.Len() > 0 { 4377 return invalidParams 4378 } else { 4379 return nil 4380 } 4381} 4382 4383func validateOpSetUserSettingsInput(v *SetUserSettingsInput) error { 4384 if v == nil { 4385 return nil 4386 } 4387 invalidParams := smithy.InvalidParamsError{Context: "SetUserSettingsInput"} 4388 if v.AccessToken == nil { 4389 invalidParams.Add(smithy.NewErrParamRequired("AccessToken")) 4390 } 4391 if v.MFAOptions == nil { 4392 invalidParams.Add(smithy.NewErrParamRequired("MFAOptions")) 4393 } 4394 if invalidParams.Len() > 0 { 4395 return invalidParams 4396 } else { 4397 return nil 4398 } 4399} 4400 4401func validateOpSignUpInput(v *SignUpInput) error { 4402 if v == nil { 4403 return nil 4404 } 4405 invalidParams := smithy.InvalidParamsError{Context: "SignUpInput"} 4406 if v.ClientId == nil { 4407 invalidParams.Add(smithy.NewErrParamRequired("ClientId")) 4408 } 4409 if v.Username == nil { 4410 invalidParams.Add(smithy.NewErrParamRequired("Username")) 4411 } 4412 if v.Password == nil { 4413 invalidParams.Add(smithy.NewErrParamRequired("Password")) 4414 } 4415 if v.UserAttributes != nil { 4416 if err := validateAttributeListType(v.UserAttributes); err != nil { 4417 invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError)) 4418 } 4419 } 4420 if v.ValidationData != nil { 4421 if err := validateAttributeListType(v.ValidationData); err != nil { 4422 invalidParams.AddNested("ValidationData", err.(smithy.InvalidParamsError)) 4423 } 4424 } 4425 if invalidParams.Len() > 0 { 4426 return invalidParams 4427 } else { 4428 return nil 4429 } 4430} 4431 4432func validateOpStartUserImportJobInput(v *StartUserImportJobInput) error { 4433 if v == nil { 4434 return nil 4435 } 4436 invalidParams := smithy.InvalidParamsError{Context: "StartUserImportJobInput"} 4437 if v.UserPoolId == nil { 4438 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4439 } 4440 if v.JobId == nil { 4441 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 4442 } 4443 if invalidParams.Len() > 0 { 4444 return invalidParams 4445 } else { 4446 return nil 4447 } 4448} 4449 4450func validateOpStopUserImportJobInput(v *StopUserImportJobInput) error { 4451 if v == nil { 4452 return nil 4453 } 4454 invalidParams := smithy.InvalidParamsError{Context: "StopUserImportJobInput"} 4455 if v.UserPoolId == nil { 4456 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4457 } 4458 if v.JobId == nil { 4459 invalidParams.Add(smithy.NewErrParamRequired("JobId")) 4460 } 4461 if invalidParams.Len() > 0 { 4462 return invalidParams 4463 } else { 4464 return nil 4465 } 4466} 4467 4468func validateOpTagResourceInput(v *TagResourceInput) error { 4469 if v == nil { 4470 return nil 4471 } 4472 invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"} 4473 if v.ResourceArn == nil { 4474 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 4475 } 4476 if v.Tags == nil { 4477 invalidParams.Add(smithy.NewErrParamRequired("Tags")) 4478 } 4479 if invalidParams.Len() > 0 { 4480 return invalidParams 4481 } else { 4482 return nil 4483 } 4484} 4485 4486func validateOpUntagResourceInput(v *UntagResourceInput) error { 4487 if v == nil { 4488 return nil 4489 } 4490 invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"} 4491 if v.ResourceArn == nil { 4492 invalidParams.Add(smithy.NewErrParamRequired("ResourceArn")) 4493 } 4494 if v.TagKeys == nil { 4495 invalidParams.Add(smithy.NewErrParamRequired("TagKeys")) 4496 } 4497 if invalidParams.Len() > 0 { 4498 return invalidParams 4499 } else { 4500 return nil 4501 } 4502} 4503 4504func validateOpUpdateAuthEventFeedbackInput(v *UpdateAuthEventFeedbackInput) error { 4505 if v == nil { 4506 return nil 4507 } 4508 invalidParams := smithy.InvalidParamsError{Context: "UpdateAuthEventFeedbackInput"} 4509 if v.UserPoolId == nil { 4510 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4511 } 4512 if v.Username == nil { 4513 invalidParams.Add(smithy.NewErrParamRequired("Username")) 4514 } 4515 if v.EventId == nil { 4516 invalidParams.Add(smithy.NewErrParamRequired("EventId")) 4517 } 4518 if v.FeedbackToken == nil { 4519 invalidParams.Add(smithy.NewErrParamRequired("FeedbackToken")) 4520 } 4521 if len(v.FeedbackValue) == 0 { 4522 invalidParams.Add(smithy.NewErrParamRequired("FeedbackValue")) 4523 } 4524 if invalidParams.Len() > 0 { 4525 return invalidParams 4526 } else { 4527 return nil 4528 } 4529} 4530 4531func validateOpUpdateDeviceStatusInput(v *UpdateDeviceStatusInput) error { 4532 if v == nil { 4533 return nil 4534 } 4535 invalidParams := smithy.InvalidParamsError{Context: "UpdateDeviceStatusInput"} 4536 if v.AccessToken == nil { 4537 invalidParams.Add(smithy.NewErrParamRequired("AccessToken")) 4538 } 4539 if v.DeviceKey == nil { 4540 invalidParams.Add(smithy.NewErrParamRequired("DeviceKey")) 4541 } 4542 if invalidParams.Len() > 0 { 4543 return invalidParams 4544 } else { 4545 return nil 4546 } 4547} 4548 4549func validateOpUpdateGroupInput(v *UpdateGroupInput) error { 4550 if v == nil { 4551 return nil 4552 } 4553 invalidParams := smithy.InvalidParamsError{Context: "UpdateGroupInput"} 4554 if v.GroupName == nil { 4555 invalidParams.Add(smithy.NewErrParamRequired("GroupName")) 4556 } 4557 if v.UserPoolId == nil { 4558 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4559 } 4560 if invalidParams.Len() > 0 { 4561 return invalidParams 4562 } else { 4563 return nil 4564 } 4565} 4566 4567func validateOpUpdateIdentityProviderInput(v *UpdateIdentityProviderInput) error { 4568 if v == nil { 4569 return nil 4570 } 4571 invalidParams := smithy.InvalidParamsError{Context: "UpdateIdentityProviderInput"} 4572 if v.UserPoolId == nil { 4573 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4574 } 4575 if v.ProviderName == nil { 4576 invalidParams.Add(smithy.NewErrParamRequired("ProviderName")) 4577 } 4578 if invalidParams.Len() > 0 { 4579 return invalidParams 4580 } else { 4581 return nil 4582 } 4583} 4584 4585func validateOpUpdateResourceServerInput(v *UpdateResourceServerInput) error { 4586 if v == nil { 4587 return nil 4588 } 4589 invalidParams := smithy.InvalidParamsError{Context: "UpdateResourceServerInput"} 4590 if v.UserPoolId == nil { 4591 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4592 } 4593 if v.Identifier == nil { 4594 invalidParams.Add(smithy.NewErrParamRequired("Identifier")) 4595 } 4596 if v.Name == nil { 4597 invalidParams.Add(smithy.NewErrParamRequired("Name")) 4598 } 4599 if v.Scopes != nil { 4600 if err := validateResourceServerScopeListType(v.Scopes); err != nil { 4601 invalidParams.AddNested("Scopes", err.(smithy.InvalidParamsError)) 4602 } 4603 } 4604 if invalidParams.Len() > 0 { 4605 return invalidParams 4606 } else { 4607 return nil 4608 } 4609} 4610 4611func validateOpUpdateUserAttributesInput(v *UpdateUserAttributesInput) error { 4612 if v == nil { 4613 return nil 4614 } 4615 invalidParams := smithy.InvalidParamsError{Context: "UpdateUserAttributesInput"} 4616 if v.UserAttributes == nil { 4617 invalidParams.Add(smithy.NewErrParamRequired("UserAttributes")) 4618 } else if v.UserAttributes != nil { 4619 if err := validateAttributeListType(v.UserAttributes); err != nil { 4620 invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError)) 4621 } 4622 } 4623 if v.AccessToken == nil { 4624 invalidParams.Add(smithy.NewErrParamRequired("AccessToken")) 4625 } 4626 if invalidParams.Len() > 0 { 4627 return invalidParams 4628 } else { 4629 return nil 4630 } 4631} 4632 4633func validateOpUpdateUserPoolClientInput(v *UpdateUserPoolClientInput) error { 4634 if v == nil { 4635 return nil 4636 } 4637 invalidParams := smithy.InvalidParamsError{Context: "UpdateUserPoolClientInput"} 4638 if v.UserPoolId == nil { 4639 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4640 } 4641 if v.ClientId == nil { 4642 invalidParams.Add(smithy.NewErrParamRequired("ClientId")) 4643 } 4644 if invalidParams.Len() > 0 { 4645 return invalidParams 4646 } else { 4647 return nil 4648 } 4649} 4650 4651func validateOpUpdateUserPoolDomainInput(v *UpdateUserPoolDomainInput) error { 4652 if v == nil { 4653 return nil 4654 } 4655 invalidParams := smithy.InvalidParamsError{Context: "UpdateUserPoolDomainInput"} 4656 if v.Domain == nil { 4657 invalidParams.Add(smithy.NewErrParamRequired("Domain")) 4658 } 4659 if v.UserPoolId == nil { 4660 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4661 } 4662 if v.CustomDomainConfig == nil { 4663 invalidParams.Add(smithy.NewErrParamRequired("CustomDomainConfig")) 4664 } else if v.CustomDomainConfig != nil { 4665 if err := validateCustomDomainConfigType(v.CustomDomainConfig); err != nil { 4666 invalidParams.AddNested("CustomDomainConfig", err.(smithy.InvalidParamsError)) 4667 } 4668 } 4669 if invalidParams.Len() > 0 { 4670 return invalidParams 4671 } else { 4672 return nil 4673 } 4674} 4675 4676func validateOpUpdateUserPoolInput(v *UpdateUserPoolInput) error { 4677 if v == nil { 4678 return nil 4679 } 4680 invalidParams := smithy.InvalidParamsError{Context: "UpdateUserPoolInput"} 4681 if v.UserPoolId == nil { 4682 invalidParams.Add(smithy.NewErrParamRequired("UserPoolId")) 4683 } 4684 if v.LambdaConfig != nil { 4685 if err := validateLambdaConfigType(v.LambdaConfig); err != nil { 4686 invalidParams.AddNested("LambdaConfig", err.(smithy.InvalidParamsError)) 4687 } 4688 } 4689 if v.SmsConfiguration != nil { 4690 if err := validateSmsConfigurationType(v.SmsConfiguration); err != nil { 4691 invalidParams.AddNested("SmsConfiguration", err.(smithy.InvalidParamsError)) 4692 } 4693 } 4694 if v.UserPoolAddOns != nil { 4695 if err := validateUserPoolAddOnsType(v.UserPoolAddOns); err != nil { 4696 invalidParams.AddNested("UserPoolAddOns", err.(smithy.InvalidParamsError)) 4697 } 4698 } 4699 if v.AccountRecoverySetting != nil { 4700 if err := validateAccountRecoverySettingType(v.AccountRecoverySetting); err != nil { 4701 invalidParams.AddNested("AccountRecoverySetting", err.(smithy.InvalidParamsError)) 4702 } 4703 } 4704 if invalidParams.Len() > 0 { 4705 return invalidParams 4706 } else { 4707 return nil 4708 } 4709} 4710 4711func validateOpVerifySoftwareTokenInput(v *VerifySoftwareTokenInput) error { 4712 if v == nil { 4713 return nil 4714 } 4715 invalidParams := smithy.InvalidParamsError{Context: "VerifySoftwareTokenInput"} 4716 if v.UserCode == nil { 4717 invalidParams.Add(smithy.NewErrParamRequired("UserCode")) 4718 } 4719 if invalidParams.Len() > 0 { 4720 return invalidParams 4721 } else { 4722 return nil 4723 } 4724} 4725 4726func validateOpVerifyUserAttributeInput(v *VerifyUserAttributeInput) error { 4727 if v == nil { 4728 return nil 4729 } 4730 invalidParams := smithy.InvalidParamsError{Context: "VerifyUserAttributeInput"} 4731 if v.AccessToken == nil { 4732 invalidParams.Add(smithy.NewErrParamRequired("AccessToken")) 4733 } 4734 if v.AttributeName == nil { 4735 invalidParams.Add(smithy.NewErrParamRequired("AttributeName")) 4736 } 4737 if v.Code == nil { 4738 invalidParams.Add(smithy.NewErrParamRequired("Code")) 4739 } 4740 if invalidParams.Len() > 0 { 4741 return invalidParams 4742 } else { 4743 return nil 4744 } 4745} 4746