// Code generated by smithy-go-codegen DO NOT EDIT.

package cognitoidentityprovider

import (
	"context"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/cognitoidentityprovider/types"
	smithy "github.com/aws/smithy-go"
	"github.com/aws/smithy-go/middleware"
)

type validateOpAddCustomAttributes struct {
}

func (*validateOpAddCustomAttributes) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAddCustomAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AddCustomAttributesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAddCustomAttributesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAddUserPoolClientSecret struct {
}

func (*validateOpAddUserPoolClientSecret) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAddUserPoolClientSecret) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AddUserPoolClientSecretInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAddUserPoolClientSecretInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminAddUserToGroup struct {
}

func (*validateOpAdminAddUserToGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminAddUserToGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminAddUserToGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminAddUserToGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminConfirmSignUp struct {
}

func (*validateOpAdminConfirmSignUp) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminConfirmSignUp) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminConfirmSignUpInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminConfirmSignUpInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminCreateUser struct {
}

func (*validateOpAdminCreateUser) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminCreateUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminCreateUserInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminCreateUserInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminDeleteUserAttributes struct {
}

func (*validateOpAdminDeleteUserAttributes) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminDeleteUserAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminDeleteUserAttributesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminDeleteUserAttributesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminDeleteUser struct {
}

func (*validateOpAdminDeleteUser) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminDeleteUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminDeleteUserInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminDeleteUserInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminDisableProviderForUser struct {
}

func (*validateOpAdminDisableProviderForUser) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminDisableProviderForUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminDisableProviderForUserInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminDisableProviderForUserInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminDisableUser struct {
}

func (*validateOpAdminDisableUser) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminDisableUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminDisableUserInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminDisableUserInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminEnableUser struct {
}

func (*validateOpAdminEnableUser) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminEnableUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminEnableUserInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminEnableUserInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminForgetDevice struct {
}

func (*validateOpAdminForgetDevice) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminForgetDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminForgetDeviceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminForgetDeviceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminGetDevice struct {
}

func (*validateOpAdminGetDevice) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminGetDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminGetDeviceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminGetDeviceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminGetUser struct {
}

func (*validateOpAdminGetUser) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminGetUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminGetUserInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminGetUserInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminInitiateAuth struct {
}

func (*validateOpAdminInitiateAuth) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminInitiateAuth) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminInitiateAuthInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminInitiateAuthInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminLinkProviderForUser struct {
}

func (*validateOpAdminLinkProviderForUser) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminLinkProviderForUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminLinkProviderForUserInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminLinkProviderForUserInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminListDevices struct {
}

func (*validateOpAdminListDevices) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminListDevices) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminListDevicesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminListDevicesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminListGroupsForUser struct {
}

func (*validateOpAdminListGroupsForUser) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminListGroupsForUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminListGroupsForUserInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminListGroupsForUserInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminListUserAuthEvents struct {
}

func (*validateOpAdminListUserAuthEvents) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminListUserAuthEvents) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminListUserAuthEventsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminListUserAuthEventsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminRemoveUserFromGroup struct {
}

func (*validateOpAdminRemoveUserFromGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminRemoveUserFromGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminRemoveUserFromGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminRemoveUserFromGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminResetUserPassword struct {
}

func (*validateOpAdminResetUserPassword) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminResetUserPassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminResetUserPasswordInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminResetUserPasswordInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminRespondToAuthChallenge struct {
}

func (*validateOpAdminRespondToAuthChallenge) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminRespondToAuthChallenge) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminRespondToAuthChallengeInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminRespondToAuthChallengeInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminSetUserMFAPreference struct {
}

func (*validateOpAdminSetUserMFAPreference) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminSetUserMFAPreference) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminSetUserMFAPreferenceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminSetUserMFAPreferenceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminSetUserPassword struct {
}

func (*validateOpAdminSetUserPassword) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminSetUserPassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminSetUserPasswordInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminSetUserPasswordInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminSetUserSettings struct {
}

func (*validateOpAdminSetUserSettings) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminSetUserSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminSetUserSettingsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminSetUserSettingsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminUpdateAuthEventFeedback struct {
}

func (*validateOpAdminUpdateAuthEventFeedback) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminUpdateAuthEventFeedback) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminUpdateAuthEventFeedbackInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminUpdateAuthEventFeedbackInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminUpdateDeviceStatus struct {
}

func (*validateOpAdminUpdateDeviceStatus) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminUpdateDeviceStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminUpdateDeviceStatusInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminUpdateDeviceStatusInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminUpdateUserAttributes struct {
}

func (*validateOpAdminUpdateUserAttributes) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminUpdateUserAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminUpdateUserAttributesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminUpdateUserAttributesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpAdminUserGlobalSignOut struct {
}

func (*validateOpAdminUserGlobalSignOut) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpAdminUserGlobalSignOut) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*AdminUserGlobalSignOutInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpAdminUserGlobalSignOutInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpChangePassword struct {
}

func (*validateOpChangePassword) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpChangePassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ChangePasswordInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpChangePasswordInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCompleteWebAuthnRegistration struct {
}

func (*validateOpCompleteWebAuthnRegistration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCompleteWebAuthnRegistration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CompleteWebAuthnRegistrationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCompleteWebAuthnRegistrationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpConfirmDevice struct {
}

func (*validateOpConfirmDevice) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpConfirmDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ConfirmDeviceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpConfirmDeviceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpConfirmForgotPassword struct {
}

func (*validateOpConfirmForgotPassword) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpConfirmForgotPassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ConfirmForgotPasswordInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpConfirmForgotPasswordInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpConfirmSignUp struct {
}

func (*validateOpConfirmSignUp) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpConfirmSignUp) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ConfirmSignUpInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpConfirmSignUpInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateGroup struct {
}

func (*validateOpCreateGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateIdentityProvider struct {
}

func (*validateOpCreateIdentityProvider) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateIdentityProvider) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateIdentityProviderInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateIdentityProviderInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateManagedLoginBranding struct {
}

func (*validateOpCreateManagedLoginBranding) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateManagedLoginBranding) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateManagedLoginBrandingInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateManagedLoginBrandingInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateResourceServer struct {
}

func (*validateOpCreateResourceServer) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateResourceServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateResourceServerInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateResourceServerInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateTerms struct {
}

func (*validateOpCreateTerms) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateTerms) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateTermsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateTermsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateUserImportJob struct {
}

func (*validateOpCreateUserImportJob) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateUserImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateUserImportJobInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateUserImportJobInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateUserPoolClient struct {
}

func (*validateOpCreateUserPoolClient) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateUserPoolClient) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateUserPoolClientInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateUserPoolClientInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateUserPoolDomain struct {
}

func (*validateOpCreateUserPoolDomain) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateUserPoolDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateUserPoolDomainInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateUserPoolDomainInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateUserPool struct {
}

func (*validateOpCreateUserPool) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateUserPool) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateUserPoolInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateUserPoolInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateUserPoolReplica struct {
}

func (*validateOpCreateUserPoolReplica) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateUserPoolReplica) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateUserPoolReplicaInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateUserPoolReplicaInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteGroup struct {
}

func (*validateOpDeleteGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteIdentityProvider struct {
}

func (*validateOpDeleteIdentityProvider) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteIdentityProvider) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteIdentityProviderInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteIdentityProviderInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteManagedLoginBranding struct {
}

func (*validateOpDeleteManagedLoginBranding) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteManagedLoginBranding) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteManagedLoginBrandingInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteManagedLoginBrandingInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteResourceServer struct {
}

func (*validateOpDeleteResourceServer) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteResourceServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteResourceServerInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteResourceServerInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteTerms struct {
}

func (*validateOpDeleteTerms) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteTerms) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteTermsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteTermsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteUserAttributes struct {
}

func (*validateOpDeleteUserAttributes) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteUserAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteUserAttributesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteUserAttributesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteUser struct {
}

func (*validateOpDeleteUser) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteUserInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteUserInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteUserPoolClient struct {
}

func (*validateOpDeleteUserPoolClient) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteUserPoolClient) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteUserPoolClientInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteUserPoolClientInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteUserPoolClientSecret struct {
}

func (*validateOpDeleteUserPoolClientSecret) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteUserPoolClientSecret) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteUserPoolClientSecretInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteUserPoolClientSecretInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteUserPoolDomain struct {
}

func (*validateOpDeleteUserPoolDomain) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteUserPoolDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteUserPoolDomainInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteUserPoolDomainInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteUserPool struct {
}

func (*validateOpDeleteUserPool) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteUserPool) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteUserPoolInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteUserPoolInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteUserPoolReplica struct {
}

func (*validateOpDeleteUserPoolReplica) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteUserPoolReplica) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteUserPoolReplicaInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteUserPoolReplicaInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteWebAuthnCredential struct {
}

func (*validateOpDeleteWebAuthnCredential) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteWebAuthnCredential) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteWebAuthnCredentialInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteWebAuthnCredentialInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeIdentityProvider struct {
}

func (*validateOpDescribeIdentityProvider) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeIdentityProvider) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeIdentityProviderInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeIdentityProviderInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeManagedLoginBrandingByClient struct {
}

func (*validateOpDescribeManagedLoginBrandingByClient) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeManagedLoginBrandingByClient) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeManagedLoginBrandingByClientInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeManagedLoginBrandingByClientInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeManagedLoginBranding struct {
}

func (*validateOpDescribeManagedLoginBranding) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeManagedLoginBranding) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeManagedLoginBrandingInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeManagedLoginBrandingInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeResourceServer struct {
}

func (*validateOpDescribeResourceServer) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeResourceServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeResourceServerInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeResourceServerInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeRiskConfiguration struct {
}

func (*validateOpDescribeRiskConfiguration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeRiskConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeRiskConfigurationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeRiskConfigurationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeTerms struct {
}

func (*validateOpDescribeTerms) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeTerms) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeTermsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeTermsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeUserImportJob struct {
}

func (*validateOpDescribeUserImportJob) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeUserImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeUserImportJobInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeUserImportJobInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeUserPoolClient struct {
}

func (*validateOpDescribeUserPoolClient) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeUserPoolClient) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeUserPoolClientInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeUserPoolClientInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeUserPoolDomain struct {
}

func (*validateOpDescribeUserPoolDomain) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeUserPoolDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeUserPoolDomainInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeUserPoolDomainInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeUserPool struct {
}

func (*validateOpDescribeUserPool) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeUserPool) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeUserPoolInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeUserPoolInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpForgetDevice struct {
}

func (*validateOpForgetDevice) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpForgetDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ForgetDeviceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpForgetDeviceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpForgotPassword struct {
}

func (*validateOpForgotPassword) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpForgotPassword) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ForgotPasswordInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpForgotPasswordInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetCSVHeader struct {
}

func (*validateOpGetCSVHeader) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetCSVHeader) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetCSVHeaderInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetCSVHeaderInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetDevice struct {
}

func (*validateOpGetDevice) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetDevice) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetDeviceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetDeviceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetGroup struct {
}

func (*validateOpGetGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetIdentityProviderByIdentifier struct {
}

func (*validateOpGetIdentityProviderByIdentifier) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetIdentityProviderByIdentifier) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetIdentityProviderByIdentifierInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetIdentityProviderByIdentifierInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetLogDeliveryConfiguration struct {
}

func (*validateOpGetLogDeliveryConfiguration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetLogDeliveryConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetLogDeliveryConfigurationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetLogDeliveryConfigurationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetProvisionedLimit struct {
}

func (*validateOpGetProvisionedLimit) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetProvisionedLimit) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetProvisionedLimitInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetProvisionedLimitInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetSigningCertificate struct {
}

func (*validateOpGetSigningCertificate) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetSigningCertificate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetSigningCertificateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetSigningCertificateInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetTokensFromRefreshToken struct {
}

func (*validateOpGetTokensFromRefreshToken) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetTokensFromRefreshToken) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetTokensFromRefreshTokenInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetTokensFromRefreshTokenInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetUICustomization struct {
}

func (*validateOpGetUICustomization) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetUICustomization) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetUICustomizationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetUICustomizationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetUserAttributeVerificationCode struct {
}

func (*validateOpGetUserAttributeVerificationCode) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetUserAttributeVerificationCode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetUserAttributeVerificationCodeInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetUserAttributeVerificationCodeInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetUserAuthFactors struct {
}

func (*validateOpGetUserAuthFactors) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetUserAuthFactors) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetUserAuthFactorsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetUserAuthFactorsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetUser struct {
}

func (*validateOpGetUser) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetUser) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetUserInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetUserInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetUserPoolMfaConfig struct {
}

func (*validateOpGetUserPoolMfaConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetUserPoolMfaConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetUserPoolMfaConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetUserPoolMfaConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGlobalSignOut struct {
}

func (*validateOpGlobalSignOut) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGlobalSignOut) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GlobalSignOutInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGlobalSignOutInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpInitiateAuth struct {
}

func (*validateOpInitiateAuth) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpInitiateAuth) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*InitiateAuthInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpInitiateAuthInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListDevices struct {
}

func (*validateOpListDevices) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListDevices) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListDevicesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListDevicesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListGroups struct {
}

func (*validateOpListGroups) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListGroups) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListGroupsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListGroupsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListIdentityProviders struct {
}

func (*validateOpListIdentityProviders) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListIdentityProviders) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListIdentityProvidersInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListIdentityProvidersInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListResourceServers struct {
}

func (*validateOpListResourceServers) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListResourceServers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListResourceServersInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListResourceServersInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListTagsForResource struct {
}

func (*validateOpListTagsForResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListTagsForResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListTagsForResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListTagsForResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListTerms struct {
}

func (*validateOpListTerms) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListTerms) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListTermsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListTermsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListUserImportJobs struct {
}

func (*validateOpListUserImportJobs) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListUserImportJobs) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListUserImportJobsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListUserImportJobsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListUserPoolClientSecrets struct {
}

func (*validateOpListUserPoolClientSecrets) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListUserPoolClientSecrets) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListUserPoolClientSecretsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListUserPoolClientSecretsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListUserPoolClients struct {
}

func (*validateOpListUserPoolClients) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListUserPoolClients) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListUserPoolClientsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListUserPoolClientsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListUserPoolReplicas struct {
}

func (*validateOpListUserPoolReplicas) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListUserPoolReplicas) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListUserPoolReplicasInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListUserPoolReplicasInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListUserPools struct {
}

func (*validateOpListUserPools) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListUserPools) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListUserPoolsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListUserPoolsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListUsersInGroup struct {
}

func (*validateOpListUsersInGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListUsersInGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListUsersInGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListUsersInGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListUsers struct {
}

func (*validateOpListUsers) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListUsers) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListUsersInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListUsersInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListWebAuthnCredentials struct {
}

func (*validateOpListWebAuthnCredentials) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListWebAuthnCredentials) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListWebAuthnCredentialsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListWebAuthnCredentialsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpResendConfirmationCode struct {
}

func (*validateOpResendConfirmationCode) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpResendConfirmationCode) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ResendConfirmationCodeInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpResendConfirmationCodeInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRespondToAuthChallenge struct {
}

func (*validateOpRespondToAuthChallenge) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRespondToAuthChallenge) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RespondToAuthChallengeInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRespondToAuthChallengeInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpRevokeToken struct {
}

func (*validateOpRevokeToken) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpRevokeToken) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*RevokeTokenInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpRevokeTokenInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSetLogDeliveryConfiguration struct {
}

func (*validateOpSetLogDeliveryConfiguration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSetLogDeliveryConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SetLogDeliveryConfigurationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSetLogDeliveryConfigurationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSetRiskConfiguration struct {
}

func (*validateOpSetRiskConfiguration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSetRiskConfiguration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SetRiskConfigurationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSetRiskConfigurationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSetUICustomization struct {
}

func (*validateOpSetUICustomization) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSetUICustomization) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SetUICustomizationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSetUICustomizationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSetUserMFAPreference struct {
}

func (*validateOpSetUserMFAPreference) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSetUserMFAPreference) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SetUserMFAPreferenceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSetUserMFAPreferenceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSetUserPoolMfaConfig struct {
}

func (*validateOpSetUserPoolMfaConfig) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSetUserPoolMfaConfig) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SetUserPoolMfaConfigInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSetUserPoolMfaConfigInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSetUserSettings struct {
}

func (*validateOpSetUserSettings) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSetUserSettings) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SetUserSettingsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSetUserSettingsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSignUp struct {
}

func (*validateOpSignUp) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSignUp) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SignUpInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSignUpInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpStartUserImportJob struct {
}

func (*validateOpStartUserImportJob) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpStartUserImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StartUserImportJobInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStartUserImportJobInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpStartWebAuthnRegistration struct {
}

func (*validateOpStartWebAuthnRegistration) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpStartWebAuthnRegistration) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StartWebAuthnRegistrationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStartWebAuthnRegistrationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpStopUserImportJob struct {
}

func (*validateOpStopUserImportJob) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpStopUserImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*StopUserImportJobInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpStopUserImportJobInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpTagResource struct {
}

func (*validateOpTagResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpTagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*TagResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpTagResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUntagResource struct {
}

func (*validateOpUntagResource) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UntagResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUntagResourceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateAuthEventFeedback struct {
}

func (*validateOpUpdateAuthEventFeedback) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateAuthEventFeedback) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateAuthEventFeedbackInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateAuthEventFeedbackInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateDeviceStatus struct {
}

func (*validateOpUpdateDeviceStatus) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateDeviceStatus) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateDeviceStatusInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateDeviceStatusInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateGroup struct {
}

func (*validateOpUpdateGroup) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateGroup) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateGroupInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateGroupInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateIdentityProvider struct {
}

func (*validateOpUpdateIdentityProvider) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateIdentityProvider) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateIdentityProviderInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateIdentityProviderInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateManagedLoginBranding struct {
}

func (*validateOpUpdateManagedLoginBranding) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateManagedLoginBranding) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateManagedLoginBrandingInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateManagedLoginBrandingInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateProvisionedLimit struct {
}

func (*validateOpUpdateProvisionedLimit) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateProvisionedLimit) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateProvisionedLimitInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateProvisionedLimitInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateResourceServer struct {
}

func (*validateOpUpdateResourceServer) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateResourceServer) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateResourceServerInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateResourceServerInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateTerms struct {
}

func (*validateOpUpdateTerms) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateTerms) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateTermsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateTermsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateUserAttributes struct {
}

func (*validateOpUpdateUserAttributes) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateUserAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateUserAttributesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateUserAttributesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateUserPoolClient struct {
}

func (*validateOpUpdateUserPoolClient) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateUserPoolClient) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateUserPoolClientInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateUserPoolClientInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateUserPoolDomain struct {
}

func (*validateOpUpdateUserPoolDomain) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateUserPoolDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateUserPoolDomainInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateUserPoolDomainInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateUserPool struct {
}

func (*validateOpUpdateUserPool) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateUserPool) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateUserPoolInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateUserPoolInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateUserPoolReplica struct {
}

func (*validateOpUpdateUserPoolReplica) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateUserPoolReplica) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateUserPoolReplicaInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateUserPoolReplicaInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpVerifySoftwareToken struct {
}

func (*validateOpVerifySoftwareToken) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpVerifySoftwareToken) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*VerifySoftwareTokenInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpVerifySoftwareTokenInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpVerifyUserAttribute struct {
}

func (*validateOpVerifyUserAttribute) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpVerifyUserAttribute) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*VerifyUserAttributeInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpVerifyUserAttributeInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

func addOpAddCustomAttributesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAddCustomAttributes{}, middleware.After)
}

func addOpAddUserPoolClientSecretValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAddUserPoolClientSecret{}, middleware.After)
}

func addOpAdminAddUserToGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminAddUserToGroup{}, middleware.After)
}

func addOpAdminConfirmSignUpValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminConfirmSignUp{}, middleware.After)
}

func addOpAdminCreateUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminCreateUser{}, middleware.After)
}

func addOpAdminDeleteUserAttributesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminDeleteUserAttributes{}, middleware.After)
}

func addOpAdminDeleteUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminDeleteUser{}, middleware.After)
}

func addOpAdminDisableProviderForUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminDisableProviderForUser{}, middleware.After)
}

func addOpAdminDisableUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminDisableUser{}, middleware.After)
}

func addOpAdminEnableUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminEnableUser{}, middleware.After)
}

func addOpAdminForgetDeviceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminForgetDevice{}, middleware.After)
}

func addOpAdminGetDeviceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminGetDevice{}, middleware.After)
}

func addOpAdminGetUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminGetUser{}, middleware.After)
}

func addOpAdminInitiateAuthValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminInitiateAuth{}, middleware.After)
}

func addOpAdminLinkProviderForUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminLinkProviderForUser{}, middleware.After)
}

func addOpAdminListDevicesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminListDevices{}, middleware.After)
}

func addOpAdminListGroupsForUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminListGroupsForUser{}, middleware.After)
}

func addOpAdminListUserAuthEventsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminListUserAuthEvents{}, middleware.After)
}

func addOpAdminRemoveUserFromGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminRemoveUserFromGroup{}, middleware.After)
}

func addOpAdminResetUserPasswordValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminResetUserPassword{}, middleware.After)
}

func addOpAdminRespondToAuthChallengeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminRespondToAuthChallenge{}, middleware.After)
}

func addOpAdminSetUserMFAPreferenceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminSetUserMFAPreference{}, middleware.After)
}

func addOpAdminSetUserPasswordValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminSetUserPassword{}, middleware.After)
}

func addOpAdminSetUserSettingsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminSetUserSettings{}, middleware.After)
}

func addOpAdminUpdateAuthEventFeedbackValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminUpdateAuthEventFeedback{}, middleware.After)
}

func addOpAdminUpdateDeviceStatusValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminUpdateDeviceStatus{}, middleware.After)
}

func addOpAdminUpdateUserAttributesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminUpdateUserAttributes{}, middleware.After)
}

func addOpAdminUserGlobalSignOutValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpAdminUserGlobalSignOut{}, middleware.After)
}

func addOpChangePasswordValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpChangePassword{}, middleware.After)
}

func addOpCompleteWebAuthnRegistrationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCompleteWebAuthnRegistration{}, middleware.After)
}

func addOpConfirmDeviceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpConfirmDevice{}, middleware.After)
}

func addOpConfirmForgotPasswordValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpConfirmForgotPassword{}, middleware.After)
}

func addOpConfirmSignUpValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpConfirmSignUp{}, middleware.After)
}

func addOpCreateGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateGroup{}, middleware.After)
}

func addOpCreateIdentityProviderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateIdentityProvider{}, middleware.After)
}

func addOpCreateManagedLoginBrandingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateManagedLoginBranding{}, middleware.After)
}

func addOpCreateResourceServerValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateResourceServer{}, middleware.After)
}

func addOpCreateTermsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTerms{}, middleware.After)
}

func addOpCreateUserImportJobValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateUserImportJob{}, middleware.After)
}

func addOpCreateUserPoolClientValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateUserPoolClient{}, middleware.After)
}

func addOpCreateUserPoolDomainValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateUserPoolDomain{}, middleware.After)
}

func addOpCreateUserPoolValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateUserPool{}, middleware.After)
}

func addOpCreateUserPoolReplicaValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateUserPoolReplica{}, middleware.After)
}

func addOpDeleteGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteGroup{}, middleware.After)
}

func addOpDeleteIdentityProviderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteIdentityProvider{}, middleware.After)
}

func addOpDeleteManagedLoginBrandingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteManagedLoginBranding{}, middleware.After)
}

func addOpDeleteResourceServerValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteResourceServer{}, middleware.After)
}

func addOpDeleteTermsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTerms{}, middleware.After)
}

func addOpDeleteUserAttributesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteUserAttributes{}, middleware.After)
}

func addOpDeleteUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteUser{}, middleware.After)
}

func addOpDeleteUserPoolClientValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteUserPoolClient{}, middleware.After)
}

func addOpDeleteUserPoolClientSecretValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteUserPoolClientSecret{}, middleware.After)
}

func addOpDeleteUserPoolDomainValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteUserPoolDomain{}, middleware.After)
}

func addOpDeleteUserPoolValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteUserPool{}, middleware.After)
}

func addOpDeleteUserPoolReplicaValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteUserPoolReplica{}, middleware.After)
}

func addOpDeleteWebAuthnCredentialValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteWebAuthnCredential{}, middleware.After)
}

func addOpDescribeIdentityProviderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeIdentityProvider{}, middleware.After)
}

func addOpDescribeManagedLoginBrandingByClientValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeManagedLoginBrandingByClient{}, middleware.After)
}

func addOpDescribeManagedLoginBrandingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeManagedLoginBranding{}, middleware.After)
}

func addOpDescribeResourceServerValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeResourceServer{}, middleware.After)
}

func addOpDescribeRiskConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeRiskConfiguration{}, middleware.After)
}

func addOpDescribeTermsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeTerms{}, middleware.After)
}

func addOpDescribeUserImportJobValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeUserImportJob{}, middleware.After)
}

func addOpDescribeUserPoolClientValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeUserPoolClient{}, middleware.After)
}

func addOpDescribeUserPoolDomainValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeUserPoolDomain{}, middleware.After)
}

func addOpDescribeUserPoolValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeUserPool{}, middleware.After)
}

func addOpForgetDeviceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpForgetDevice{}, middleware.After)
}

func addOpForgotPasswordValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpForgotPassword{}, middleware.After)
}

func addOpGetCSVHeaderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetCSVHeader{}, middleware.After)
}

func addOpGetDeviceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDevice{}, middleware.After)
}

func addOpGetGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetGroup{}, middleware.After)
}

func addOpGetIdentityProviderByIdentifierValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIdentityProviderByIdentifier{}, middleware.After)
}

func addOpGetLogDeliveryConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetLogDeliveryConfiguration{}, middleware.After)
}

func addOpGetProvisionedLimitValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetProvisionedLimit{}, middleware.After)
}

func addOpGetSigningCertificateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetSigningCertificate{}, middleware.After)
}

func addOpGetTokensFromRefreshTokenValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetTokensFromRefreshToken{}, middleware.After)
}

func addOpGetUICustomizationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetUICustomization{}, middleware.After)
}

func addOpGetUserAttributeVerificationCodeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetUserAttributeVerificationCode{}, middleware.After)
}

func addOpGetUserAuthFactorsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetUserAuthFactors{}, middleware.After)
}

func addOpGetUserValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetUser{}, middleware.After)
}

func addOpGetUserPoolMfaConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetUserPoolMfaConfig{}, middleware.After)
}

func addOpGlobalSignOutValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGlobalSignOut{}, middleware.After)
}

func addOpInitiateAuthValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpInitiateAuth{}, middleware.After)
}

func addOpListDevicesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListDevices{}, middleware.After)
}

func addOpListGroupsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListGroups{}, middleware.After)
}

func addOpListIdentityProvidersValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListIdentityProviders{}, middleware.After)
}

func addOpListResourceServersValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListResourceServers{}, middleware.After)
}

func addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListTagsForResource{}, middleware.After)
}

func addOpListTermsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListTerms{}, middleware.After)
}

func addOpListUserImportJobsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListUserImportJobs{}, middleware.After)
}

func addOpListUserPoolClientSecretsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListUserPoolClientSecrets{}, middleware.After)
}

func addOpListUserPoolClientsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListUserPoolClients{}, middleware.After)
}

func addOpListUserPoolReplicasValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListUserPoolReplicas{}, middleware.After)
}

func addOpListUserPoolsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListUserPools{}, middleware.After)
}

func addOpListUsersInGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListUsersInGroup{}, middleware.After)
}

func addOpListUsersValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListUsers{}, middleware.After)
}

func addOpListWebAuthnCredentialsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListWebAuthnCredentials{}, middleware.After)
}

func addOpResendConfirmationCodeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpResendConfirmationCode{}, middleware.After)
}

func addOpRespondToAuthChallengeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRespondToAuthChallenge{}, middleware.After)
}

func addOpRevokeTokenValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRevokeToken{}, middleware.After)
}

func addOpSetLogDeliveryConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSetLogDeliveryConfiguration{}, middleware.After)
}

func addOpSetRiskConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSetRiskConfiguration{}, middleware.After)
}

func addOpSetUICustomizationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSetUICustomization{}, middleware.After)
}

func addOpSetUserMFAPreferenceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSetUserMFAPreference{}, middleware.After)
}

func addOpSetUserPoolMfaConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSetUserPoolMfaConfig{}, middleware.After)
}

func addOpSetUserSettingsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSetUserSettings{}, middleware.After)
}

func addOpSignUpValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSignUp{}, middleware.After)
}

func addOpStartUserImportJobValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartUserImportJob{}, middleware.After)
}

func addOpStartWebAuthnRegistrationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartWebAuthnRegistration{}, middleware.After)
}

func addOpStopUserImportJobValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStopUserImportJob{}, middleware.After)
}

func addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
}

func addOpUntagResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUntagResource{}, middleware.After)
}

func addOpUpdateAuthEventFeedbackValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAuthEventFeedback{}, middleware.After)
}

func addOpUpdateDeviceStatusValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateDeviceStatus{}, middleware.After)
}

func addOpUpdateGroupValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateGroup{}, middleware.After)
}

func addOpUpdateIdentityProviderValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateIdentityProvider{}, middleware.After)
}

func addOpUpdateManagedLoginBrandingValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateManagedLoginBranding{}, middleware.After)
}

func addOpUpdateProvisionedLimitValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateProvisionedLimit{}, middleware.After)
}

func addOpUpdateResourceServerValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateResourceServer{}, middleware.After)
}

func addOpUpdateTermsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateTerms{}, middleware.After)
}

func addOpUpdateUserAttributesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateUserAttributes{}, middleware.After)
}

func addOpUpdateUserPoolClientValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateUserPoolClient{}, middleware.After)
}

func addOpUpdateUserPoolDomainValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateUserPoolDomain{}, middleware.After)
}

func addOpUpdateUserPoolValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateUserPool{}, middleware.After)
}

func addOpUpdateUserPoolReplicaValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateUserPoolReplica{}, middleware.After)
}

func addOpVerifySoftwareTokenValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpVerifySoftwareToken{}, middleware.After)
}

func addOpVerifyUserAttributeValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpVerifyUserAttribute{}, middleware.After)
}

func validateAccountRecoverySettingType(v *types.AccountRecoverySettingType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AccountRecoverySettingType"}
	if v.RecoveryMechanisms != nil {
		if err := validateRecoveryMechanismsType(v.RecoveryMechanisms); err != nil {
			invalidParams.AddNested("RecoveryMechanisms", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAccountTakeoverActionsType(v *types.AccountTakeoverActionsType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AccountTakeoverActionsType"}
	if v.LowAction != nil {
		if err := validateAccountTakeoverActionType(v.LowAction); err != nil {
			invalidParams.AddNested("LowAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.MediumAction != nil {
		if err := validateAccountTakeoverActionType(v.MediumAction); err != nil {
			invalidParams.AddNested("MediumAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.HighAction != nil {
		if err := validateAccountTakeoverActionType(v.HighAction); err != nil {
			invalidParams.AddNested("HighAction", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAccountTakeoverActionType(v *types.AccountTakeoverActionType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AccountTakeoverActionType"}
	if len(v.EventAction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EventAction"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAccountTakeoverRiskConfigurationType(v *types.AccountTakeoverRiskConfigurationType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AccountTakeoverRiskConfigurationType"}
	if v.NotifyConfiguration != nil {
		if err := validateNotifyConfigurationType(v.NotifyConfiguration); err != nil {
			invalidParams.AddNested("NotifyConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Actions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
	} else if v.Actions != nil {
		if err := validateAccountTakeoverActionsType(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAssetListType(v []types.AssetType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssetListType"}
	for i := range v {
		if err := validateAssetType(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAssetType(v *types.AssetType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssetType"}
	if len(v.Category) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Category"))
	}
	if len(v.ColorMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ColorMode"))
	}
	if len(v.Extension) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Extension"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAttributeListType(v []types.AttributeType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttributeListType"}
	for i := range v {
		if err := validateAttributeType(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAttributeType(v *types.AttributeType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttributeType"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCompromisedCredentialsActionsType(v *types.CompromisedCredentialsActionsType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CompromisedCredentialsActionsType"}
	if len(v.EventAction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EventAction"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCompromisedCredentialsRiskConfigurationType(v *types.CompromisedCredentialsRiskConfigurationType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CompromisedCredentialsRiskConfigurationType"}
	if v.Actions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Actions"))
	} else if v.Actions != nil {
		if err := validateCompromisedCredentialsActionsType(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContextDataType(v *types.ContextDataType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContextDataType"}
	if v.IpAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpAddress"))
	}
	if v.ServerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerName"))
	}
	if v.ServerPath == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerPath"))
	}
	if v.HttpHeaders == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HttpHeaders"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomDomainConfigType(v *types.CustomDomainConfigType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomDomainConfigType"}
	if v.CertificateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CertificateArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomEmailLambdaVersionConfigType(v *types.CustomEmailLambdaVersionConfigType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomEmailLambdaVersionConfigType"}
	if len(v.LambdaVersion) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LambdaVersion"))
	}
	if v.LambdaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LambdaArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomSMSLambdaVersionConfigType(v *types.CustomSMSLambdaVersionConfigType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomSMSLambdaVersionConfigType"}
	if len(v.LambdaVersion) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LambdaVersion"))
	}
	if v.LambdaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LambdaArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEumsSmsConfigurationType(v *types.EumsSmsConfigurationType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EumsSmsConfigurationType"}
	if v.CallerArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CallerArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFailoverType(v *types.FailoverType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FailoverType"}
	if v.SecondaryRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecondaryRegion"))
	}
	if v.PrimaryRoute53HealthCheckId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrimaryRoute53HealthCheckId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInboundFederationLambdaType(v *types.InboundFederationLambdaType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InboundFederationLambdaType"}
	if len(v.LambdaVersion) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LambdaVersion"))
	}
	if v.LambdaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LambdaArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLambdaConfigType(v *types.LambdaConfigType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LambdaConfigType"}
	if v.PreTokenGenerationConfig != nil {
		if err := validatePreTokenGenerationVersionConfigType(v.PreTokenGenerationConfig); err != nil {
			invalidParams.AddNested("PreTokenGenerationConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomSMSSender != nil {
		if err := validateCustomSMSLambdaVersionConfigType(v.CustomSMSSender); err != nil {
			invalidParams.AddNested("CustomSMSSender", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomEmailSender != nil {
		if err := validateCustomEmailLambdaVersionConfigType(v.CustomEmailSender); err != nil {
			invalidParams.AddNested("CustomEmailSender", err.(smithy.InvalidParamsError))
		}
	}
	if v.InboundFederation != nil {
		if err := validateInboundFederationLambdaType(v.InboundFederation); err != nil {
			invalidParams.AddNested("InboundFederation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLimitDefinitionType(v *types.LimitDefinitionType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LimitDefinitionType"}
	if len(v.LimitClass) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LimitClass"))
	}
	if v.Attributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLogConfigurationListType(v []types.LogConfigurationType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LogConfigurationListType"}
	for i := range v {
		if err := validateLogConfigurationType(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLogConfigurationType(v *types.LogConfigurationType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LogConfigurationType"}
	if len(v.LogLevel) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LogLevel"))
	}
	if len(v.EventSource) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EventSource"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNotifyConfigurationType(v *types.NotifyConfigurationType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NotifyConfigurationType"}
	if v.SourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceArn"))
	}
	if v.BlockEmail != nil {
		if err := validateNotifyEmailType(v.BlockEmail); err != nil {
			invalidParams.AddNested("BlockEmail", err.(smithy.InvalidParamsError))
		}
	}
	if v.NoActionEmail != nil {
		if err := validateNotifyEmailType(v.NoActionEmail); err != nil {
			invalidParams.AddNested("NoActionEmail", err.(smithy.InvalidParamsError))
		}
	}
	if v.MfaEmail != nil {
		if err := validateNotifyEmailType(v.MfaEmail); err != nil {
			invalidParams.AddNested("MfaEmail", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNotifyEmailType(v *types.NotifyEmailType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NotifyEmailType"}
	if v.Subject == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Subject"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePreTokenGenerationVersionConfigType(v *types.PreTokenGenerationVersionConfigType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PreTokenGenerationVersionConfigType"}
	if len(v.LambdaVersion) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LambdaVersion"))
	}
	if v.LambdaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LambdaArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRecoveryMechanismsType(v []types.RecoveryOptionType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecoveryMechanismsType"}
	for i := range v {
		if err := validateRecoveryOptionType(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRecoveryOptionType(v *types.RecoveryOptionType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecoveryOptionType"}
	if v.Priority == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Priority"))
	}
	if len(v.Name) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRefreshTokenRotationType(v *types.RefreshTokenRotationType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RefreshTokenRotationType"}
	if len(v.Feature) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Feature"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResourceServerScopeListType(v []types.ResourceServerScopeType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourceServerScopeListType"}
	for i := range v {
		if err := validateResourceServerScopeType(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateResourceServerScopeType(v *types.ResourceServerScopeType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourceServerScopeType"}
	if v.ScopeName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScopeName"))
	}
	if v.ScopeDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScopeDescription"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRoutingType(v *types.RoutingType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RoutingType"}
	if v.Failover != nil {
		if err := validateFailoverType(v.Failover); err != nil {
			invalidParams.AddNested("Failover", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSmsConfigurationType(v *types.SmsConfigurationType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SmsConfigurationType"}
	if v.EumsSms != nil {
		if err := validateEumsSmsConfigurationType(v.EumsSms); err != nil {
			invalidParams.AddNested("EumsSms", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSmsMfaConfigType(v *types.SmsMfaConfigType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SmsMfaConfigType"}
	if v.SmsConfiguration != nil {
		if err := validateSmsConfigurationType(v.SmsConfiguration); err != nil {
			invalidParams.AddNested("SmsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUsernameConfigurationType(v *types.UsernameConfigurationType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UsernameConfigurationType"}
	if v.CaseSensitive == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CaseSensitive"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUserPoolAddOnsType(v *types.UserPoolAddOnsType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UserPoolAddOnsType"}
	if len(v.AdvancedSecurityMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AdvancedSecurityMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddCustomAttributesInput(v *AddCustomAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddCustomAttributesInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.CustomAttributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomAttributes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddUserPoolClientSecretInput(v *AddUserPoolClientSecretInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddUserPoolClientSecretInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminAddUserToGroupInput(v *AdminAddUserToGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminAddUserToGroupInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminConfirmSignUpInput(v *AdminConfirmSignUpInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminConfirmSignUpInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminCreateUserInput(v *AdminCreateUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminCreateUserInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.UserAttributes != nil {
		if err := validateAttributeListType(v.UserAttributes); err != nil {
			invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.ValidationData != nil {
		if err := validateAttributeListType(v.ValidationData); err != nil {
			invalidParams.AddNested("ValidationData", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminDeleteUserAttributesInput(v *AdminDeleteUserAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminDeleteUserAttributesInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.UserAttributeNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserAttributeNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminDeleteUserInput(v *AdminDeleteUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminDeleteUserInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminDisableProviderForUserInput(v *AdminDisableProviderForUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminDisableProviderForUserInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.User == nil {
		invalidParams.Add(smithy.NewErrParamRequired("User"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminDisableUserInput(v *AdminDisableUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminDisableUserInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminEnableUserInput(v *AdminEnableUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminEnableUserInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminForgetDeviceInput(v *AdminForgetDeviceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminForgetDeviceInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.DeviceKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminGetDeviceInput(v *AdminGetDeviceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminGetDeviceInput"}
	if v.DeviceKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceKey"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminGetUserInput(v *AdminGetUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminGetUserInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminInitiateAuthInput(v *AdminInitiateAuthInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminInitiateAuthInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if len(v.AuthFlow) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AuthFlow"))
	}
	if v.ContextData != nil {
		if err := validateContextDataType(v.ContextData); err != nil {
			invalidParams.AddNested("ContextData", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminLinkProviderForUserInput(v *AdminLinkProviderForUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminLinkProviderForUserInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.DestinationUser == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationUser"))
	}
	if v.SourceUser == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceUser"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminListDevicesInput(v *AdminListDevicesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminListDevicesInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminListGroupsForUserInput(v *AdminListGroupsForUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminListGroupsForUserInput"}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminListUserAuthEventsInput(v *AdminListUserAuthEventsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminListUserAuthEventsInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminRemoveUserFromGroupInput(v *AdminRemoveUserFromGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminRemoveUserFromGroupInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminResetUserPasswordInput(v *AdminResetUserPasswordInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminResetUserPasswordInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminRespondToAuthChallengeInput(v *AdminRespondToAuthChallengeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminRespondToAuthChallengeInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if len(v.ChallengeName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ChallengeName"))
	}
	if v.ContextData != nil {
		if err := validateContextDataType(v.ContextData); err != nil {
			invalidParams.AddNested("ContextData", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminSetUserMFAPreferenceInput(v *AdminSetUserMFAPreferenceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminSetUserMFAPreferenceInput"}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminSetUserPasswordInput(v *AdminSetUserPasswordInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminSetUserPasswordInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.Password == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminSetUserSettingsInput(v *AdminSetUserSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminSetUserSettingsInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.MFAOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MFAOptions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminUpdateAuthEventFeedbackInput(v *AdminUpdateAuthEventFeedbackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminUpdateAuthEventFeedbackInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.EventId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventId"))
	}
	if len(v.FeedbackValue) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FeedbackValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminUpdateDeviceStatusInput(v *AdminUpdateDeviceStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminUpdateDeviceStatusInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.DeviceKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminUpdateUserAttributesInput(v *AdminUpdateUserAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminUpdateUserAttributesInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.UserAttributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserAttributes"))
	} else if v.UserAttributes != nil {
		if err := validateAttributeListType(v.UserAttributes); err != nil {
			invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAdminUserGlobalSignOutInput(v *AdminUserGlobalSignOutInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AdminUserGlobalSignOutInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpChangePasswordInput(v *ChangePasswordInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChangePasswordInput"}
	if v.ProposedPassword == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProposedPassword"))
	}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCompleteWebAuthnRegistrationInput(v *CompleteWebAuthnRegistrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CompleteWebAuthnRegistrationInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if v.Credential == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Credential"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpConfirmDeviceInput(v *ConfirmDeviceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfirmDeviceInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if v.DeviceKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpConfirmForgotPasswordInput(v *ConfirmForgotPasswordInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfirmForgotPasswordInput"}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.ConfirmationCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfirmationCode"))
	}
	if v.Password == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpConfirmSignUpInput(v *ConfirmSignUpInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfirmSignUpInput"}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.ConfirmationCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfirmationCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateGroupInput(v *CreateGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGroupInput"}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIdentityProviderInput(v *CreateIdentityProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIdentityProviderInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ProviderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProviderName"))
	}
	if len(v.ProviderType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ProviderType"))
	}
	if v.ProviderDetails == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProviderDetails"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateManagedLoginBrandingInput(v *CreateManagedLoginBrandingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateManagedLoginBrandingInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if v.Assets != nil {
		if err := validateAssetListType(v.Assets); err != nil {
			invalidParams.AddNested("Assets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateResourceServerInput(v *CreateResourceServerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateResourceServerInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Scopes != nil {
		if err := validateResourceServerScopeListType(v.Scopes); err != nil {
			invalidParams.AddNested("Scopes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTermsInput(v *CreateTermsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTermsInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if v.TermsName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TermsName"))
	}
	if len(v.TermsSource) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TermsSource"))
	}
	if len(v.Enforcement) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Enforcement"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateUserImportJobInput(v *CreateUserImportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserImportJobInput"}
	if v.JobName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobName"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.CloudWatchLogsRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CloudWatchLogsRoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateUserPoolClientInput(v *CreateUserPoolClientInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserPoolClientInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ClientName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientName"))
	}
	if v.RefreshTokenRotation != nil {
		if err := validateRefreshTokenRotationType(v.RefreshTokenRotation); err != nil {
			invalidParams.AddNested("RefreshTokenRotation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateUserPoolDomainInput(v *CreateUserPoolDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserPoolDomainInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.CustomDomainConfig != nil {
		if err := validateCustomDomainConfigType(v.CustomDomainConfig); err != nil {
			invalidParams.AddNested("CustomDomainConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Routing != nil {
		if err := validateRoutingType(v.Routing); err != nil {
			invalidParams.AddNested("Routing", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateUserPoolInput(v *CreateUserPoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserPoolInput"}
	if v.PoolName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoolName"))
	}
	if v.LambdaConfig != nil {
		if err := validateLambdaConfigType(v.LambdaConfig); err != nil {
			invalidParams.AddNested("LambdaConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.SmsConfiguration != nil {
		if err := validateSmsConfigurationType(v.SmsConfiguration); err != nil {
			invalidParams.AddNested("SmsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.UserPoolAddOns != nil {
		if err := validateUserPoolAddOnsType(v.UserPoolAddOns); err != nil {
			invalidParams.AddNested("UserPoolAddOns", err.(smithy.InvalidParamsError))
		}
	}
	if v.UsernameConfiguration != nil {
		if err := validateUsernameConfigurationType(v.UsernameConfiguration); err != nil {
			invalidParams.AddNested("UsernameConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.AccountRecoverySetting != nil {
		if err := validateAccountRecoverySettingType(v.AccountRecoverySetting); err != nil {
			invalidParams.AddNested("AccountRecoverySetting", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateUserPoolReplicaInput(v *CreateUserPoolReplicaInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserPoolReplicaInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.RegionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteGroupInput(v *DeleteGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteGroupInput"}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIdentityProviderInput(v *DeleteIdentityProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIdentityProviderInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ProviderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProviderName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteManagedLoginBrandingInput(v *DeleteManagedLoginBrandingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteManagedLoginBrandingInput"}
	if v.ManagedLoginBrandingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ManagedLoginBrandingId"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteResourceServerInput(v *DeleteResourceServerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteResourceServerInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTermsInput(v *DeleteTermsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTermsInput"}
	if v.TermsId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TermsId"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteUserAttributesInput(v *DeleteUserAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserAttributesInput"}
	if v.UserAttributeNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserAttributeNames"))
	}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteUserInput(v *DeleteUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteUserPoolClientInput(v *DeleteUserPoolClientInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserPoolClientInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteUserPoolClientSecretInput(v *DeleteUserPoolClientSecretInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserPoolClientSecretInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if v.ClientSecretId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientSecretId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteUserPoolDomainInput(v *DeleteUserPoolDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserPoolDomainInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteUserPoolInput(v *DeleteUserPoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserPoolInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteUserPoolReplicaInput(v *DeleteUserPoolReplicaInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserPoolReplicaInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.RegionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteWebAuthnCredentialInput(v *DeleteWebAuthnCredentialInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteWebAuthnCredentialInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if v.CredentialId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CredentialId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeIdentityProviderInput(v *DescribeIdentityProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeIdentityProviderInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ProviderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProviderName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeManagedLoginBrandingByClientInput(v *DescribeManagedLoginBrandingByClientInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeManagedLoginBrandingByClientInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeManagedLoginBrandingInput(v *DescribeManagedLoginBrandingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeManagedLoginBrandingInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ManagedLoginBrandingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ManagedLoginBrandingId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeResourceServerInput(v *DescribeResourceServerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeResourceServerInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeRiskConfigurationInput(v *DescribeRiskConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeRiskConfigurationInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeTermsInput(v *DescribeTermsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeTermsInput"}
	if v.TermsId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TermsId"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeUserImportJobInput(v *DescribeUserImportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserImportJobInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeUserPoolClientInput(v *DescribeUserPoolClientInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserPoolClientInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeUserPoolDomainInput(v *DescribeUserPoolDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserPoolDomainInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeUserPoolInput(v *DescribeUserPoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeUserPoolInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpForgetDeviceInput(v *ForgetDeviceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ForgetDeviceInput"}
	if v.DeviceKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpForgotPasswordInput(v *ForgotPasswordInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ForgotPasswordInput"}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCSVHeaderInput(v *GetCSVHeaderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCSVHeaderInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDeviceInput(v *GetDeviceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDeviceInput"}
	if v.DeviceKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetGroupInput(v *GetGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetGroupInput"}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIdentityProviderByIdentifierInput(v *GetIdentityProviderByIdentifierInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIdentityProviderByIdentifierInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.IdpIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdpIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetLogDeliveryConfigurationInput(v *GetLogDeliveryConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLogDeliveryConfigurationInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetProvisionedLimitInput(v *GetProvisionedLimitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetProvisionedLimitInput"}
	if v.LimitDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LimitDefinition"))
	} else if v.LimitDefinition != nil {
		if err := validateLimitDefinitionType(v.LimitDefinition); err != nil {
			invalidParams.AddNested("LimitDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSigningCertificateInput(v *GetSigningCertificateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSigningCertificateInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTokensFromRefreshTokenInput(v *GetTokensFromRefreshTokenInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTokensFromRefreshTokenInput"}
	if v.RefreshToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RefreshToken"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUICustomizationInput(v *GetUICustomizationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUICustomizationInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUserAttributeVerificationCodeInput(v *GetUserAttributeVerificationCodeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUserAttributeVerificationCodeInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if v.AttributeName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUserAuthFactorsInput(v *GetUserAuthFactorsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUserAuthFactorsInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUserInput(v *GetUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUserInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUserPoolMfaConfigInput(v *GetUserPoolMfaConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUserPoolMfaConfigInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGlobalSignOutInput(v *GlobalSignOutInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GlobalSignOutInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpInitiateAuthInput(v *InitiateAuthInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InitiateAuthInput"}
	if len(v.AuthFlow) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("AuthFlow"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDevicesInput(v *ListDevicesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDevicesInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListGroupsInput(v *ListGroupsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListGroupsInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListIdentityProvidersInput(v *ListIdentityProvidersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListIdentityProvidersInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListResourceServersInput(v *ListResourceServersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListResourceServersInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListTagsForResourceInput(v *ListTagsForResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTagsForResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListTermsInput(v *ListTermsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTermsInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListUserImportJobsInput(v *ListUserImportJobsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListUserImportJobsInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.MaxResults == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxResults"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListUserPoolClientSecretsInput(v *ListUserPoolClientSecretsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListUserPoolClientSecretsInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListUserPoolClientsInput(v *ListUserPoolClientsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListUserPoolClientsInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListUserPoolReplicasInput(v *ListUserPoolReplicasInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListUserPoolReplicasInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListUserPoolsInput(v *ListUserPoolsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListUserPoolsInput"}
	if v.MaxResults == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxResults"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListUsersInGroupInput(v *ListUsersInGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListUsersInGroupInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListUsersInput(v *ListUsersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListUsersInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListWebAuthnCredentialsInput(v *ListWebAuthnCredentialsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListWebAuthnCredentialsInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpResendConfirmationCodeInput(v *ResendConfirmationCodeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResendConfirmationCodeInput"}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRespondToAuthChallengeInput(v *RespondToAuthChallengeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RespondToAuthChallengeInput"}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if len(v.ChallengeName) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ChallengeName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRevokeTokenInput(v *RevokeTokenInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RevokeTokenInput"}
	if v.Token == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Token"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetLogDeliveryConfigurationInput(v *SetLogDeliveryConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetLogDeliveryConfigurationInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.LogConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LogConfigurations"))
	} else if v.LogConfigurations != nil {
		if err := validateLogConfigurationListType(v.LogConfigurations); err != nil {
			invalidParams.AddNested("LogConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetRiskConfigurationInput(v *SetRiskConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetRiskConfigurationInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.CompromisedCredentialsRiskConfiguration != nil {
		if err := validateCompromisedCredentialsRiskConfigurationType(v.CompromisedCredentialsRiskConfiguration); err != nil {
			invalidParams.AddNested("CompromisedCredentialsRiskConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.AccountTakeoverRiskConfiguration != nil {
		if err := validateAccountTakeoverRiskConfigurationType(v.AccountTakeoverRiskConfiguration); err != nil {
			invalidParams.AddNested("AccountTakeoverRiskConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetUICustomizationInput(v *SetUICustomizationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetUICustomizationInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetUserMFAPreferenceInput(v *SetUserMFAPreferenceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetUserMFAPreferenceInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetUserPoolMfaConfigInput(v *SetUserPoolMfaConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetUserPoolMfaConfigInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.SmsMfaConfiguration != nil {
		if err := validateSmsMfaConfigType(v.SmsMfaConfiguration); err != nil {
			invalidParams.AddNested("SmsMfaConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetUserSettingsInput(v *SetUserSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetUserSettingsInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if v.MFAOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MFAOptions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSignUpInput(v *SignUpInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SignUpInput"}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.UserAttributes != nil {
		if err := validateAttributeListType(v.UserAttributes); err != nil {
			invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.ValidationData != nil {
		if err := validateAttributeListType(v.ValidationData); err != nil {
			invalidParams.AddNested("ValidationData", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartUserImportJobInput(v *StartUserImportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartUserImportJobInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartWebAuthnRegistrationInput(v *StartWebAuthnRegistrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartWebAuthnRegistrationInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopUserImportJobInput(v *StopUserImportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopUserImportJobInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTagResourceInput(v *TagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUntagResourceInput(v *UntagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateAuthEventFeedbackInput(v *UpdateAuthEventFeedbackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAuthEventFeedbackInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if v.EventId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventId"))
	}
	if v.FeedbackToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FeedbackToken"))
	}
	if len(v.FeedbackValue) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FeedbackValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDeviceStatusInput(v *UpdateDeviceStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDeviceStatusInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if v.DeviceKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateGroupInput(v *UpdateGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGroupInput"}
	if v.GroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupName"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateIdentityProviderInput(v *UpdateIdentityProviderInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateIdentityProviderInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ProviderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProviderName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateManagedLoginBrandingInput(v *UpdateManagedLoginBrandingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateManagedLoginBrandingInput"}
	if v.Assets != nil {
		if err := validateAssetListType(v.Assets); err != nil {
			invalidParams.AddNested("Assets", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateProvisionedLimitInput(v *UpdateProvisionedLimitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateProvisionedLimitInput"}
	if v.LimitDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LimitDefinition"))
	} else if v.LimitDefinition != nil {
		if err := validateLimitDefinitionType(v.LimitDefinition); err != nil {
			invalidParams.AddNested("LimitDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateResourceServerInput(v *UpdateResourceServerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateResourceServerInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Scopes != nil {
		if err := validateResourceServerScopeListType(v.Scopes); err != nil {
			invalidParams.AddNested("Scopes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTermsInput(v *UpdateTermsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTermsInput"}
	if v.TermsId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TermsId"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserAttributesInput(v *UpdateUserAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserAttributesInput"}
	if v.UserAttributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserAttributes"))
	} else if v.UserAttributes != nil {
		if err := validateAttributeListType(v.UserAttributes); err != nil {
			invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserPoolClientInput(v *UpdateUserPoolClientInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserPoolClientInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if v.RefreshTokenRotation != nil {
		if err := validateRefreshTokenRotationType(v.RefreshTokenRotation); err != nil {
			invalidParams.AddNested("RefreshTokenRotation", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserPoolDomainInput(v *UpdateUserPoolDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserPoolDomainInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.CustomDomainConfig != nil {
		if err := validateCustomDomainConfigType(v.CustomDomainConfig); err != nil {
			invalidParams.AddNested("CustomDomainConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Routing != nil {
		if err := validateRoutingType(v.Routing); err != nil {
			invalidParams.AddNested("Routing", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserPoolInput(v *UpdateUserPoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserPoolInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.LambdaConfig != nil {
		if err := validateLambdaConfigType(v.LambdaConfig); err != nil {
			invalidParams.AddNested("LambdaConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.SmsConfiguration != nil {
		if err := validateSmsConfigurationType(v.SmsConfiguration); err != nil {
			invalidParams.AddNested("SmsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.UserPoolAddOns != nil {
		if err := validateUserPoolAddOnsType(v.UserPoolAddOns); err != nil {
			invalidParams.AddNested("UserPoolAddOns", err.(smithy.InvalidParamsError))
		}
	}
	if v.AccountRecoverySetting != nil {
		if err := validateAccountRecoverySettingType(v.AccountRecoverySetting); err != nil {
			invalidParams.AddNested("AccountRecoverySetting", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserPoolReplicaInput(v *UpdateUserPoolReplicaInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserPoolReplicaInput"}
	if v.UserPoolId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserPoolId"))
	}
	if v.RegionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RegionName"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpVerifySoftwareTokenInput(v *VerifySoftwareTokenInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VerifySoftwareTokenInput"}
	if v.UserCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpVerifyUserAttributeInput(v *VerifyUserAttributeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VerifyUserAttributeInput"}
	if v.AccessToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessToken"))
	}
	if v.AttributeName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeName"))
	}
	if v.Code == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Code"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}
