Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccountRecoverySettingType

type AccountRecoverySettingType struct {

	// The list of RecoveryOptionTypes.
	RecoveryMechanisms []RecoveryOptionType
}

    The data type for AccountRecoverySetting.

    type AccountTakeoverActionType

    type AccountTakeoverActionType struct {
    
    	// The event action.
    	//
    	// * BLOCK Choosing this action will block the request.
    	//
    	// *
    	// MFA_IF_CONFIGURED Throw MFA challenge if user has configured it, else allow the
    	// request.
    	//
    	// * MFA_REQUIRED Throw MFA challenge if user has configured it, else
    	// block the request.
    	//
    	// * NO_ACTION Allow the user sign-in.
    	//
    	// This member is required.
    	EventAction AccountTakeoverEventActionType
    
    	// Flag specifying whether to send a notification.
    	//
    	// This member is required.
    	Notify bool
    }

      Account takeover action type.

      type AccountTakeoverActionsType

      type AccountTakeoverActionsType struct {
      
      	// Action to take for a high risk.
      	HighAction *AccountTakeoverActionType
      
      	// Action to take for a low risk.
      	LowAction *AccountTakeoverActionType
      
      	// Action to take for a medium risk.
      	MediumAction *AccountTakeoverActionType
      }

        Account takeover actions type.

        type AccountTakeoverEventActionType

        type AccountTakeoverEventActionType string
        const (
        	AccountTakeoverEventActionTypeBlock           AccountTakeoverEventActionType = "BLOCK"
        	AccountTakeoverEventActionTypeMfaIfConfigured AccountTakeoverEventActionType = "MFA_IF_CONFIGURED"
        	AccountTakeoverEventActionTypeMfaRequired     AccountTakeoverEventActionType = "MFA_REQUIRED"
        	AccountTakeoverEventActionTypeNoAction        AccountTakeoverEventActionType = "NO_ACTION"
        )

          Enum values for AccountTakeoverEventActionType

          func (AccountTakeoverEventActionType) Values

            Values returns all known values for AccountTakeoverEventActionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

            type AccountTakeoverRiskConfigurationType

            type AccountTakeoverRiskConfigurationType struct {
            
            	// Account takeover risk configuration actions
            	//
            	// This member is required.
            	Actions *AccountTakeoverActionsType
            
            	// The notify configuration used to construct email notifications.
            	NotifyConfiguration *NotifyConfigurationType
            }

              Configuration for mitigation actions and notification for different levels of risk detected for a potential account takeover.

              type AdminCreateUserConfigType

              type AdminCreateUserConfigType struct {
              
              	// Set to True if only the administrator is allowed to create user profiles. Set to
              	// False if users can sign themselves up via an app.
              	AllowAdminCreateUserOnly bool
              
              	// The message template to be used for the welcome message to new users. See also
              	// Customizing User Invitation Messages
              	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pool-settings-message-customizations.html#cognito-user-pool-settings-user-invitation-message-customization).
              	InviteMessageTemplate *MessageTemplateType
              
              	// The user account expiration limit, in days, after which the account is no longer
              	// usable. To reset the account after that time limit, you must call
              	// AdminCreateUser again, specifying "RESEND" for the MessageAction parameter. The
              	// default value for this parameter is 7. If you set a value for
              	// TemporaryPasswordValidityDays in PasswordPolicy, that value will be used and
              	// UnusedAccountValidityDays will be deprecated for that user pool.
              	UnusedAccountValidityDays int32
              }

                The configuration for creating a new user profile.

                type AdvancedSecurityModeType

                type AdvancedSecurityModeType string
                const (
                	AdvancedSecurityModeTypeOff      AdvancedSecurityModeType = "OFF"
                	AdvancedSecurityModeTypeAudit    AdvancedSecurityModeType = "AUDIT"
                	AdvancedSecurityModeTypeEnforced AdvancedSecurityModeType = "ENFORCED"
                )

                  Enum values for AdvancedSecurityModeType

                  func (AdvancedSecurityModeType) Values

                    Values returns all known values for AdvancedSecurityModeType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                    type AliasAttributeType

                    type AliasAttributeType string
                    const (
                    	AliasAttributeTypePhoneNumber       AliasAttributeType = "phone_number"
                    	AliasAttributeTypeEmail             AliasAttributeType = "email"
                    	AliasAttributeTypePreferredUsername AliasAttributeType = "preferred_username"
                    )

                      Enum values for AliasAttributeType

                      func (AliasAttributeType) Values

                        Values returns all known values for AliasAttributeType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                        type AliasExistsException

                        type AliasExistsException struct {
                        	Message *string
                        }

                          This exception is thrown when a user tries to confirm the account with an email or phone number that has already been supplied as an alias from a different account. This exception tells user that an account with this email or phone already exists.

                          func (*AliasExistsException) Error

                          func (e *AliasExistsException) Error() string

                          func (*AliasExistsException) ErrorCode

                          func (e *AliasExistsException) ErrorCode() string

                          func (*AliasExistsException) ErrorFault

                          func (e *AliasExistsException) ErrorFault() smithy.ErrorFault

                          func (*AliasExistsException) ErrorMessage

                          func (e *AliasExistsException) ErrorMessage() string

                          type AnalyticsConfigurationType

                          type AnalyticsConfigurationType struct {
                          
                          	// The Amazon Resource Name (ARN) of an Amazon Pinpoint project. You can use the
                          	// Amazon Pinpoint project for Pinpoint integration with the chosen User Pool
                          	// Client. Amazon Cognito publishes events to the pinpoint project declared by the
                          	// app ARN.
                          	ApplicationArn *string
                          
                          	// The application ID for an Amazon Pinpoint application.
                          	ApplicationId *string
                          
                          	// The external ID.
                          	ExternalId *string
                          
                          	// The ARN of an IAM role that authorizes Amazon Cognito to publish events to
                          	// Amazon Pinpoint analytics.
                          	RoleArn *string
                          
                          	// If UserDataShared is true, Amazon Cognito will include user data in the events
                          	// it publishes to Amazon Pinpoint analytics.
                          	UserDataShared bool
                          }

                            The Amazon Pinpoint analytics configuration for collecting metrics for a user pool. In regions where Pinpoint is not available, Cognito User Pools only supports sending events to Amazon Pinpoint projects in us-east-1. In regions where Pinpoint is available, Cognito User Pools will support sending events to Amazon Pinpoint projects within that same region.

                            type AnalyticsMetadataType

                            type AnalyticsMetadataType struct {
                            
                            	// The endpoint ID.
                            	AnalyticsEndpointId *string
                            }

                              An Amazon Pinpoint analytics endpoint. An endpoint uniquely identifies a mobile device, email address, or phone number that can receive messages from Amazon Pinpoint analytics. Cognito User Pools only supports sending events to Amazon Pinpoint projects in the US East (N. Virginia) us-east-1 Region, regardless of the region in which the user pool resides.

                              type AttributeDataType

                              type AttributeDataType string
                              const (
                              	AttributeDataTypeString   AttributeDataType = "String"
                              	AttributeDataTypeNumber   AttributeDataType = "Number"
                              	AttributeDataTypeDatetime AttributeDataType = "DateTime"
                              	AttributeDataTypeBoolean  AttributeDataType = "Boolean"
                              )

                                Enum values for AttributeDataType

                                func (AttributeDataType) Values

                                  Values returns all known values for AttributeDataType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                  type AttributeType

                                  type AttributeType struct {
                                  
                                  	// The name of the attribute.
                                  	//
                                  	// This member is required.
                                  	Name *string
                                  
                                  	// The value of the attribute.
                                  	Value *string
                                  }

                                    Specifies whether the attribute is standard or custom.

                                    type AuthEventType

                                    type AuthEventType struct {
                                    
                                    	// The challenge responses.
                                    	ChallengeResponses []ChallengeResponseType
                                    
                                    	// The creation date
                                    	CreationDate *time.Time
                                    
                                    	// The user context data captured at the time of an event request. It provides
                                    	// additional information about the client from which event the request is
                                    	// received.
                                    	EventContextData *EventContextDataType
                                    
                                    	// A flag specifying the user feedback captured at the time of an event request is
                                    	// good or bad.
                                    	EventFeedback *EventFeedbackType
                                    
                                    	// The event ID.
                                    	EventId *string
                                    
                                    	// The event response.
                                    	EventResponse EventResponseType
                                    
                                    	// The event risk.
                                    	EventRisk *EventRiskType
                                    
                                    	// The event type.
                                    	EventType EventType
                                    }

                                      The authentication event type.

                                      type AuthFlowType

                                      type AuthFlowType string
                                      const (
                                      	AuthFlowTypeUserSrpAuth           AuthFlowType = "USER_SRP_AUTH"
                                      	AuthFlowTypeRefreshTokenAuth      AuthFlowType = "REFRESH_TOKEN_AUTH"
                                      	AuthFlowTypeRefreshToken          AuthFlowType = "REFRESH_TOKEN"
                                      	AuthFlowTypeCustomAuth            AuthFlowType = "CUSTOM_AUTH"
                                      	AuthFlowTypeAdminNoSrpAuth        AuthFlowType = "ADMIN_NO_SRP_AUTH"
                                      	AuthFlowTypeUserPasswordAuth      AuthFlowType = "USER_PASSWORD_AUTH"
                                      	AuthFlowTypeAdminUserPasswordAuth AuthFlowType = "ADMIN_USER_PASSWORD_AUTH"
                                      )

                                        Enum values for AuthFlowType

                                        func (AuthFlowType) Values

                                        func (AuthFlowType) Values() []AuthFlowType

                                          Values returns all known values for AuthFlowType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                          type AuthenticationResultType

                                          type AuthenticationResultType struct {
                                          
                                          	// The access token.
                                          	AccessToken *string
                                          
                                          	// The expiration period of the authentication result in seconds.
                                          	ExpiresIn int32
                                          
                                          	// The ID token.
                                          	IdToken *string
                                          
                                          	// The new device metadata from an authentication result.
                                          	NewDeviceMetadata *NewDeviceMetadataType
                                          
                                          	// The refresh token.
                                          	RefreshToken *string
                                          
                                          	// The token type.
                                          	TokenType *string
                                          }

                                            The authentication result.

                                            type ChallengeName

                                            type ChallengeName string
                                            const (
                                            	ChallengeNamePassword ChallengeName = "Password"
                                            	ChallengeNameMfa      ChallengeName = "Mfa"
                                            )

                                              Enum values for ChallengeName

                                              func (ChallengeName) Values

                                              func (ChallengeName) Values() []ChallengeName

                                                Values returns all known values for ChallengeName. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                type ChallengeNameType

                                                type ChallengeNameType string
                                                const (
                                                	ChallengeNameTypeSmsMfa                 ChallengeNameType = "SMS_MFA"
                                                	ChallengeNameTypeSoftwareTokenMfa       ChallengeNameType = "SOFTWARE_TOKEN_MFA"
                                                	ChallengeNameTypeSelectMfaType          ChallengeNameType = "SELECT_MFA_TYPE"
                                                	ChallengeNameTypeMfaSetup               ChallengeNameType = "MFA_SETUP"
                                                	ChallengeNameTypePasswordVerifier       ChallengeNameType = "PASSWORD_VERIFIER"
                                                	ChallengeNameTypeCustomChallenge        ChallengeNameType = "CUSTOM_CHALLENGE"
                                                	ChallengeNameTypeDeviceSrpAuth          ChallengeNameType = "DEVICE_SRP_AUTH"
                                                	ChallengeNameTypeDevicePasswordVerifier ChallengeNameType = "DEVICE_PASSWORD_VERIFIER"
                                                	ChallengeNameTypeAdminNoSrpAuth         ChallengeNameType = "ADMIN_NO_SRP_AUTH"
                                                	ChallengeNameTypeNewPasswordRequired    ChallengeNameType = "NEW_PASSWORD_REQUIRED"
                                                )

                                                  Enum values for ChallengeNameType

                                                  func (ChallengeNameType) Values

                                                    Values returns all known values for ChallengeNameType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                    type ChallengeResponse

                                                    type ChallengeResponse string
                                                    const (
                                                    	ChallengeResponseSuccess ChallengeResponse = "Success"
                                                    	ChallengeResponseFailure ChallengeResponse = "Failure"
                                                    )

                                                      Enum values for ChallengeResponse

                                                      func (ChallengeResponse) Values

                                                        Values returns all known values for ChallengeResponse. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                        type ChallengeResponseType

                                                        type ChallengeResponseType struct {
                                                        
                                                        	// The challenge name
                                                        	ChallengeName ChallengeName
                                                        
                                                        	// The challenge response.
                                                        	ChallengeResponse ChallengeResponse
                                                        }

                                                          The challenge response type.

                                                          type CodeDeliveryDetailsType

                                                          type CodeDeliveryDetailsType struct {
                                                          
                                                          	// The attribute name.
                                                          	AttributeName *string
                                                          
                                                          	// The delivery medium (email message or phone number).
                                                          	DeliveryMedium DeliveryMediumType
                                                          
                                                          	// The destination for the code delivery details.
                                                          	Destination *string
                                                          }

                                                            The code delivery details being returned from the server.

                                                            type CodeDeliveryFailureException

                                                            type CodeDeliveryFailureException struct {
                                                            	Message *string
                                                            }

                                                              This exception is thrown when a verification code fails to deliver successfully.

                                                              func (*CodeDeliveryFailureException) Error

                                                              func (*CodeDeliveryFailureException) ErrorCode

                                                              func (e *CodeDeliveryFailureException) ErrorCode() string

                                                              func (*CodeDeliveryFailureException) ErrorFault

                                                              func (*CodeDeliveryFailureException) ErrorMessage

                                                              func (e *CodeDeliveryFailureException) ErrorMessage() string

                                                              type CodeMismatchException

                                                              type CodeMismatchException struct {
                                                              	Message *string
                                                              }

                                                                This exception is thrown if the provided code does not match what the server was expecting.

                                                                func (*CodeMismatchException) Error

                                                                func (e *CodeMismatchException) Error() string

                                                                func (*CodeMismatchException) ErrorCode

                                                                func (e *CodeMismatchException) ErrorCode() string

                                                                func (*CodeMismatchException) ErrorFault

                                                                func (e *CodeMismatchException) ErrorFault() smithy.ErrorFault

                                                                func (*CodeMismatchException) ErrorMessage

                                                                func (e *CodeMismatchException) ErrorMessage() string

                                                                type CompromisedCredentialsActionsType

                                                                type CompromisedCredentialsActionsType struct {
                                                                
                                                                	// The event action.
                                                                	//
                                                                	// This member is required.
                                                                	EventAction CompromisedCredentialsEventActionType
                                                                }

                                                                  The compromised credentials actions type

                                                                  type CompromisedCredentialsEventActionType

                                                                  type CompromisedCredentialsEventActionType string
                                                                  const (
                                                                  	CompromisedCredentialsEventActionTypeBlock    CompromisedCredentialsEventActionType = "BLOCK"
                                                                  	CompromisedCredentialsEventActionTypeNoAction CompromisedCredentialsEventActionType = "NO_ACTION"
                                                                  )

                                                                    Enum values for CompromisedCredentialsEventActionType

                                                                    func (CompromisedCredentialsEventActionType) Values

                                                                      Values returns all known values for CompromisedCredentialsEventActionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                      type CompromisedCredentialsRiskConfigurationType

                                                                      type CompromisedCredentialsRiskConfigurationType struct {
                                                                      
                                                                      	// The compromised credentials risk configuration actions.
                                                                      	//
                                                                      	// This member is required.
                                                                      	Actions *CompromisedCredentialsActionsType
                                                                      
                                                                      	// Perform the action for these events. The default is to perform all events if no
                                                                      	// event filter is specified.
                                                                      	EventFilter []EventFilterType
                                                                      }

                                                                        The compromised credentials risk configuration type.

                                                                        type ConcurrentModificationException

                                                                        type ConcurrentModificationException struct {
                                                                        	Message *string
                                                                        }

                                                                          This exception is thrown if two or more modifications are happening concurrently.

                                                                          func (*ConcurrentModificationException) Error

                                                                          func (*ConcurrentModificationException) ErrorCode

                                                                          func (e *ConcurrentModificationException) ErrorCode() string

                                                                          func (*ConcurrentModificationException) ErrorFault

                                                                          func (*ConcurrentModificationException) ErrorMessage

                                                                          func (e *ConcurrentModificationException) ErrorMessage() string

                                                                          type ContextDataType

                                                                          type ContextDataType struct {
                                                                          
                                                                          	// HttpHeaders received on your server in same order.
                                                                          	//
                                                                          	// This member is required.
                                                                          	HttpHeaders []HttpHeader
                                                                          
                                                                          	// Source IP address of your user.
                                                                          	//
                                                                          	// This member is required.
                                                                          	IpAddress *string
                                                                          
                                                                          	// Your server endpoint where this API is invoked.
                                                                          	//
                                                                          	// This member is required.
                                                                          	ServerName *string
                                                                          
                                                                          	// Your server path where this API is invoked.
                                                                          	//
                                                                          	// This member is required.
                                                                          	ServerPath *string
                                                                          
                                                                          	// Encoded data containing device fingerprinting details, collected using the
                                                                          	// Amazon Cognito context data collection library.
                                                                          	EncodedData *string
                                                                          }

                                                                            Contextual user data type used for evaluating the risk of an unexpected event by Amazon Cognito advanced security.

                                                                            type CustomDomainConfigType

                                                                            type CustomDomainConfigType struct {
                                                                            
                                                                            	// The Amazon Resource Name (ARN) of an AWS Certificate Manager SSL certificate.
                                                                            	// You use this certificate for the subdomain of your custom domain.
                                                                            	//
                                                                            	// This member is required.
                                                                            	CertificateArn *string
                                                                            }

                                                                              The configuration for a custom domain that hosts the sign-up and sign-in webpages for your application.

                                                                              type CustomEmailLambdaVersionConfigType

                                                                              type CustomEmailLambdaVersionConfigType struct {
                                                                              
                                                                              	// The Lambda Amazon Resource Name of the Lambda function that Amazon Cognito
                                                                              	// triggers to send email notifications to users.
                                                                              	//
                                                                              	// This member is required.
                                                                              	LambdaArn *string
                                                                              
                                                                              	// The Lambda version represents the signature of the "request" attribute in the
                                                                              	// "event" information Amazon Cognito passes to your custom email Lambda function.
                                                                              	// The only supported value is V1_0.
                                                                              	//
                                                                              	// This member is required.
                                                                              	LambdaVersion CustomEmailSenderLambdaVersionType
                                                                              }

                                                                                A custom email sender Lambda configuration type.

                                                                                type CustomEmailSenderLambdaVersionType

                                                                                type CustomEmailSenderLambdaVersionType string
                                                                                const (
                                                                                	CustomEmailSenderLambdaVersionTypeV10 CustomEmailSenderLambdaVersionType = "V1_0"
                                                                                )

                                                                                  Enum values for CustomEmailSenderLambdaVersionType

                                                                                  func (CustomEmailSenderLambdaVersionType) Values

                                                                                    Values returns all known values for CustomEmailSenderLambdaVersionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                    type CustomSMSLambdaVersionConfigType

                                                                                    type CustomSMSLambdaVersionConfigType struct {
                                                                                    
                                                                                    	// The Lambda Amazon Resource Name of the Lambda function that Amazon Cognito
                                                                                    	// triggers to send SMS notifications to users.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	LambdaArn *string
                                                                                    
                                                                                    	// The Lambda version represents the signature of the "request" attribute in the
                                                                                    	// "event" information Amazon Cognito passes to your custom SMS Lambda function.
                                                                                    	// The only supported value is V1_0.
                                                                                    	//
                                                                                    	// This member is required.
                                                                                    	LambdaVersion CustomSMSSenderLambdaVersionType
                                                                                    }

                                                                                      A custom SMS sender Lambda configuration type.

                                                                                      type CustomSMSSenderLambdaVersionType

                                                                                      type CustomSMSSenderLambdaVersionType string
                                                                                      const (
                                                                                      	CustomSMSSenderLambdaVersionTypeV10 CustomSMSSenderLambdaVersionType = "V1_0"
                                                                                      )

                                                                                        Enum values for CustomSMSSenderLambdaVersionType

                                                                                        func (CustomSMSSenderLambdaVersionType) Values

                                                                                          Values returns all known values for CustomSMSSenderLambdaVersionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                          type DefaultEmailOptionType

                                                                                          type DefaultEmailOptionType string
                                                                                          const (
                                                                                          	DefaultEmailOptionTypeConfirmWithLink DefaultEmailOptionType = "CONFIRM_WITH_LINK"
                                                                                          	DefaultEmailOptionTypeConfirmWithCode DefaultEmailOptionType = "CONFIRM_WITH_CODE"
                                                                                          )

                                                                                            Enum values for DefaultEmailOptionType

                                                                                            func (DefaultEmailOptionType) Values

                                                                                              Values returns all known values for DefaultEmailOptionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                              type DeliveryMediumType

                                                                                              type DeliveryMediumType string
                                                                                              const (
                                                                                              	DeliveryMediumTypeSms   DeliveryMediumType = "SMS"
                                                                                              	DeliveryMediumTypeEmail DeliveryMediumType = "EMAIL"
                                                                                              )

                                                                                                Enum values for DeliveryMediumType

                                                                                                func (DeliveryMediumType) Values

                                                                                                  Values returns all known values for DeliveryMediumType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                  type DeviceConfigurationType

                                                                                                  type DeviceConfigurationType struct {
                                                                                                  
                                                                                                  	// Indicates whether a challenge is required on a new device. Only applicable to a
                                                                                                  	// new device.
                                                                                                  	ChallengeRequiredOnNewDevice bool
                                                                                                  
                                                                                                  	// If true, a device is only remembered on user prompt.
                                                                                                  	DeviceOnlyRememberedOnUserPrompt bool
                                                                                                  }

                                                                                                    The configuration for the user pool's device tracking.

                                                                                                    type DeviceRememberedStatusType

                                                                                                    type DeviceRememberedStatusType string
                                                                                                    const (
                                                                                                    	DeviceRememberedStatusTypeRemembered    DeviceRememberedStatusType = "remembered"
                                                                                                    	DeviceRememberedStatusTypeNotRemembered DeviceRememberedStatusType = "not_remembered"
                                                                                                    )

                                                                                                      Enum values for DeviceRememberedStatusType

                                                                                                      func (DeviceRememberedStatusType) Values

                                                                                                        Values returns all known values for DeviceRememberedStatusType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                        type DeviceSecretVerifierConfigType

                                                                                                        type DeviceSecretVerifierConfigType struct {
                                                                                                        
                                                                                                        	// The password verifier.
                                                                                                        	PasswordVerifier *string
                                                                                                        
                                                                                                        	// The salt.
                                                                                                        	Salt *string
                                                                                                        }

                                                                                                          The device verifier against which it will be authenticated.

                                                                                                          type DeviceType

                                                                                                          type DeviceType struct {
                                                                                                          
                                                                                                          	// The device attributes.
                                                                                                          	DeviceAttributes []AttributeType
                                                                                                          
                                                                                                          	// The creation date of the device.
                                                                                                          	DeviceCreateDate *time.Time
                                                                                                          
                                                                                                          	// The device key.
                                                                                                          	DeviceKey *string
                                                                                                          
                                                                                                          	// The date in which the device was last authenticated.
                                                                                                          	DeviceLastAuthenticatedDate *time.Time
                                                                                                          
                                                                                                          	// The last modified date of the device.
                                                                                                          	DeviceLastModifiedDate *time.Time
                                                                                                          }

                                                                                                            The device type.

                                                                                                            type DomainDescriptionType

                                                                                                            type DomainDescriptionType struct {
                                                                                                            
                                                                                                            	// The AWS account ID for the user pool owner.
                                                                                                            	AWSAccountId *string
                                                                                                            
                                                                                                            	// The ARN of the CloudFront distribution.
                                                                                                            	CloudFrontDistribution *string
                                                                                                            
                                                                                                            	// The configuration for a custom domain that hosts the sign-up and sign-in
                                                                                                            	// webpages for your application.
                                                                                                            	CustomDomainConfig *CustomDomainConfigType
                                                                                                            
                                                                                                            	// The domain string.
                                                                                                            	Domain *string
                                                                                                            
                                                                                                            	// The S3 bucket where the static files for this domain are stored.
                                                                                                            	S3Bucket *string
                                                                                                            
                                                                                                            	// The domain status.
                                                                                                            	Status DomainStatusType
                                                                                                            
                                                                                                            	// The user pool ID.
                                                                                                            	UserPoolId *string
                                                                                                            
                                                                                                            	// The app version.
                                                                                                            	Version *string
                                                                                                            }

                                                                                                              A container for information about a domain.

                                                                                                              type DomainStatusType

                                                                                                              type DomainStatusType string
                                                                                                              const (
                                                                                                              	DomainStatusTypeCreating DomainStatusType = "CREATING"
                                                                                                              	DomainStatusTypeDeleting DomainStatusType = "DELETING"
                                                                                                              	DomainStatusTypeUpdating DomainStatusType = "UPDATING"
                                                                                                              	DomainStatusTypeActive   DomainStatusType = "ACTIVE"
                                                                                                              	DomainStatusTypeFailed   DomainStatusType = "FAILED"
                                                                                                              )

                                                                                                                Enum values for DomainStatusType

                                                                                                                func (DomainStatusType) Values

                                                                                                                  Values returns all known values for DomainStatusType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                  type DuplicateProviderException

                                                                                                                  type DuplicateProviderException struct {
                                                                                                                  	Message *string
                                                                                                                  }

                                                                                                                    This exception is thrown when the provider is already supported by the user pool.

                                                                                                                    func (*DuplicateProviderException) Error

                                                                                                                    func (*DuplicateProviderException) ErrorCode

                                                                                                                    func (e *DuplicateProviderException) ErrorCode() string

                                                                                                                    func (*DuplicateProviderException) ErrorFault

                                                                                                                    func (*DuplicateProviderException) ErrorMessage

                                                                                                                    func (e *DuplicateProviderException) ErrorMessage() string

                                                                                                                    type EmailConfigurationType

                                                                                                                    type EmailConfigurationType struct {
                                                                                                                    
                                                                                                                    	// The set of configuration rules that can be applied to emails sent using Amazon
                                                                                                                    	// SES. A configuration set is applied to an email by including a reference to the
                                                                                                                    	// configuration set in the headers of the email. Once applied, all of the rules in
                                                                                                                    	// that configuration set are applied to the email. Configuration sets can be used
                                                                                                                    	// to apply the following types of rules to emails:
                                                                                                                    	//
                                                                                                                    	// * Event publishing – Amazon
                                                                                                                    	// SES can track the number of send, delivery, open, click, bounce, and complaint
                                                                                                                    	// events for each email sent. Use event publishing to send information about these
                                                                                                                    	// events to other AWS services such as SNS and CloudWatch.
                                                                                                                    	//
                                                                                                                    	// * IP pool management –
                                                                                                                    	// When leasing dedicated IP addresses with Amazon SES, you can create groups of IP
                                                                                                                    	// addresses, called dedicated IP pools. You can then associate the dedicated IP
                                                                                                                    	// pools with configuration sets.
                                                                                                                    	ConfigurationSet *string
                                                                                                                    
                                                                                                                    	// Specifies whether Amazon Cognito emails your users by using its built-in email
                                                                                                                    	// functionality or your Amazon SES email configuration. Specify one of the
                                                                                                                    	// following values: COGNITO_DEFAULT When Amazon Cognito emails your users, it uses
                                                                                                                    	// its built-in email functionality. When you use the default option, Amazon
                                                                                                                    	// Cognito allows only a limited number of emails each day for your user pool. For
                                                                                                                    	// typical production environments, the default email limit is below the required
                                                                                                                    	// delivery volume. To achieve a higher delivery volume, specify DEVELOPER to use
                                                                                                                    	// your Amazon SES email configuration. To look up the email delivery limit for the
                                                                                                                    	// default option, see Limits in Amazon Cognito
                                                                                                                    	// (https://docs.aws.amazon.com/cognito/latest/developerguide/limits.html) in the
                                                                                                                    	// Amazon Cognito Developer Guide. The default FROM address is
                                                                                                                    	// no-reply@verificationemail.com. To customize the FROM address, provide the ARN
                                                                                                                    	// of an Amazon SES verified email address for the SourceArn parameter. If
                                                                                                                    	// EmailSendingAccount is COGNITO_DEFAULT, the following parameters aren't
                                                                                                                    	// allowed:
                                                                                                                    	//
                                                                                                                    	// * EmailVerificationMessage
                                                                                                                    	//
                                                                                                                    	// * EmailVerificationSubject
                                                                                                                    	//
                                                                                                                    	// *
                                                                                                                    	// InviteMessageTemplate.EmailMessage
                                                                                                                    	//
                                                                                                                    	// * InviteMessageTemplate.EmailSubject
                                                                                                                    	//
                                                                                                                    	// *
                                                                                                                    	// VerificationMessageTemplate.EmailMessage
                                                                                                                    	//
                                                                                                                    	// *
                                                                                                                    	// VerificationMessageTemplate.EmailMessageByLink
                                                                                                                    	//
                                                                                                                    	// *
                                                                                                                    	// VerificationMessageTemplate.EmailSubject,
                                                                                                                    	//
                                                                                                                    	// *
                                                                                                                    	// VerificationMessageTemplate.EmailSubjectByLink
                                                                                                                    	//
                                                                                                                    	// DEVELOPER EmailSendingAccount is
                                                                                                                    	// required.
                                                                                                                    	//
                                                                                                                    	// DEVELOPER When Amazon Cognito emails your users, it uses your Amazon
                                                                                                                    	// SES configuration. Amazon Cognito calls Amazon SES on your behalf to send email
                                                                                                                    	// from your verified email address. When you use this option, the email delivery
                                                                                                                    	// limits are the same limits that apply to your Amazon SES verified email address
                                                                                                                    	// in your AWS account. If you use this option, you must provide the ARN of an
                                                                                                                    	// Amazon SES verified email address for the SourceArn parameter. Before Amazon
                                                                                                                    	// Cognito can email your users, it requires additional permissions to call Amazon
                                                                                                                    	// SES on your behalf. When you update your user pool with this option, Amazon
                                                                                                                    	// Cognito creates a service-linked role, which is a type of IAM role, in your AWS
                                                                                                                    	// account. This role contains the permissions that allow Amazon Cognito to access
                                                                                                                    	// Amazon SES and send email messages with your address. For more information about
                                                                                                                    	// the service-linked role that Amazon Cognito creates, see Using Service-Linked
                                                                                                                    	// Roles for Amazon Cognito
                                                                                                                    	// (https://docs.aws.amazon.com/cognito/latest/developerguide/using-service-linked-roles.html)
                                                                                                                    	// in the Amazon Cognito Developer Guide.
                                                                                                                    	EmailSendingAccount EmailSendingAccountType
                                                                                                                    
                                                                                                                    	// Identifies either the sender’s email address or the sender’s name with their
                                                                                                                    	// email address. For example, testuser@example.com or Test User . This address
                                                                                                                    	// will appear before the body of the email.
                                                                                                                    	From *string
                                                                                                                    
                                                                                                                    	// The destination to which the receiver of the email should reply to.
                                                                                                                    	ReplyToEmailAddress *string
                                                                                                                    
                                                                                                                    	// The Amazon Resource Name (ARN) of a verified email address in Amazon SES. This
                                                                                                                    	// email address is used in one of the following ways, depending on the value that
                                                                                                                    	// you specify for the EmailSendingAccount parameter:
                                                                                                                    	//
                                                                                                                    	// * If you specify
                                                                                                                    	// COGNITO_DEFAULT, Amazon Cognito uses this address as the custom FROM address
                                                                                                                    	// when it emails your users by using its built-in email account.
                                                                                                                    	//
                                                                                                                    	// * If you specify
                                                                                                                    	// DEVELOPER, Amazon Cognito emails your users with this address by calling Amazon
                                                                                                                    	// SES on your behalf.
                                                                                                                    	SourceArn *string
                                                                                                                    }

                                                                                                                      The email configuration type. Amazon Cognito has specific regions for use with Amazon SES. For more information on the supported regions, see Email Settings for Amazon Cognito User Pools (https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-email.html).

                                                                                                                      type EmailSendingAccountType

                                                                                                                      type EmailSendingAccountType string
                                                                                                                      const (
                                                                                                                      	EmailSendingAccountTypeCognitoDefault EmailSendingAccountType = "COGNITO_DEFAULT"
                                                                                                                      	EmailSendingAccountTypeDeveloper      EmailSendingAccountType = "DEVELOPER"
                                                                                                                      )

                                                                                                                        Enum values for EmailSendingAccountType

                                                                                                                        func (EmailSendingAccountType) Values

                                                                                                                          Values returns all known values for EmailSendingAccountType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                          type EnableSoftwareTokenMFAException

                                                                                                                          type EnableSoftwareTokenMFAException struct {
                                                                                                                          	Message *string
                                                                                                                          }

                                                                                                                            This exception is thrown when there is a code mismatch and the service fails to configure the software token TOTP multi-factor authentication (MFA).

                                                                                                                            func (*EnableSoftwareTokenMFAException) Error

                                                                                                                            func (*EnableSoftwareTokenMFAException) ErrorCode

                                                                                                                            func (e *EnableSoftwareTokenMFAException) ErrorCode() string

                                                                                                                            func (*EnableSoftwareTokenMFAException) ErrorFault

                                                                                                                            func (*EnableSoftwareTokenMFAException) ErrorMessage

                                                                                                                            func (e *EnableSoftwareTokenMFAException) ErrorMessage() string

                                                                                                                            type EventContextDataType

                                                                                                                            type EventContextDataType struct {
                                                                                                                            
                                                                                                                            	// The user's city.
                                                                                                                            	City *string
                                                                                                                            
                                                                                                                            	// The user's country.
                                                                                                                            	Country *string
                                                                                                                            
                                                                                                                            	// The user's device name.
                                                                                                                            	DeviceName *string
                                                                                                                            
                                                                                                                            	// The user's IP address.
                                                                                                                            	IpAddress *string
                                                                                                                            
                                                                                                                            	// The user's time zone.
                                                                                                                            	Timezone *string
                                                                                                                            }

                                                                                                                              Specifies the user context data captured at the time of an event request.

                                                                                                                              type EventFeedbackType

                                                                                                                              type EventFeedbackType struct {
                                                                                                                              
                                                                                                                              	// The event feedback value.
                                                                                                                              	//
                                                                                                                              	// This member is required.
                                                                                                                              	FeedbackValue FeedbackValueType
                                                                                                                              
                                                                                                                              	// The provider.
                                                                                                                              	//
                                                                                                                              	// This member is required.
                                                                                                                              	Provider *string
                                                                                                                              
                                                                                                                              	// The event feedback date.
                                                                                                                              	FeedbackDate *time.Time
                                                                                                                              }

                                                                                                                                Specifies the event feedback type.

                                                                                                                                type EventFilterType

                                                                                                                                type EventFilterType string
                                                                                                                                const (
                                                                                                                                	EventFilterTypeSignIn         EventFilterType = "SIGN_IN"
                                                                                                                                	EventFilterTypePasswordChange EventFilterType = "PASSWORD_CHANGE"
                                                                                                                                	EventFilterTypeSignUp         EventFilterType = "SIGN_UP"
                                                                                                                                )

                                                                                                                                  Enum values for EventFilterType

                                                                                                                                  func (EventFilterType) Values

                                                                                                                                  func (EventFilterType) Values() []EventFilterType

                                                                                                                                    Values returns all known values for EventFilterType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                    type EventResponseType

                                                                                                                                    type EventResponseType string
                                                                                                                                    const (
                                                                                                                                    	EventResponseTypeSuccess EventResponseType = "Success"
                                                                                                                                    	EventResponseTypeFailure EventResponseType = "Failure"
                                                                                                                                    )

                                                                                                                                      Enum values for EventResponseType

                                                                                                                                      func (EventResponseType) Values

                                                                                                                                        Values returns all known values for EventResponseType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                        type EventRiskType

                                                                                                                                        type EventRiskType struct {
                                                                                                                                        
                                                                                                                                        	// Indicates whether compromised credentials were detected during an authentication
                                                                                                                                        	// event.
                                                                                                                                        	CompromisedCredentialsDetected *bool
                                                                                                                                        
                                                                                                                                        	// The risk decision.
                                                                                                                                        	RiskDecision RiskDecisionType
                                                                                                                                        
                                                                                                                                        	// The risk level.
                                                                                                                                        	RiskLevel RiskLevelType
                                                                                                                                        }

                                                                                                                                          The event risk type.

                                                                                                                                          type EventType

                                                                                                                                          type EventType string
                                                                                                                                          const (
                                                                                                                                          	EventTypeSignIn         EventType = "SignIn"
                                                                                                                                          	EventTypeSignUp         EventType = "SignUp"
                                                                                                                                          	EventTypeForgotPassword EventType = "ForgotPassword"
                                                                                                                                          )

                                                                                                                                            Enum values for EventType

                                                                                                                                            func (EventType) Values

                                                                                                                                            func (EventType) Values() []EventType

                                                                                                                                              Values returns all known values for EventType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                              type ExpiredCodeException

                                                                                                                                              type ExpiredCodeException struct {
                                                                                                                                              	Message *string
                                                                                                                                              }

                                                                                                                                                This exception is thrown if a code has expired.

                                                                                                                                                func (*ExpiredCodeException) Error

                                                                                                                                                func (e *ExpiredCodeException) Error() string

                                                                                                                                                func (*ExpiredCodeException) ErrorCode

                                                                                                                                                func (e *ExpiredCodeException) ErrorCode() string

                                                                                                                                                func (*ExpiredCodeException) ErrorFault

                                                                                                                                                func (e *ExpiredCodeException) ErrorFault() smithy.ErrorFault

                                                                                                                                                func (*ExpiredCodeException) ErrorMessage

                                                                                                                                                func (e *ExpiredCodeException) ErrorMessage() string

                                                                                                                                                type ExplicitAuthFlowsType

                                                                                                                                                type ExplicitAuthFlowsType string
                                                                                                                                                const (
                                                                                                                                                	ExplicitAuthFlowsTypeAdminNoSrpAuth             ExplicitAuthFlowsType = "ADMIN_NO_SRP_AUTH"
                                                                                                                                                	ExplicitAuthFlowsTypeCustomAuthFlowOnly         ExplicitAuthFlowsType = "CUSTOM_AUTH_FLOW_ONLY"
                                                                                                                                                	ExplicitAuthFlowsTypeUserPasswordAuth           ExplicitAuthFlowsType = "USER_PASSWORD_AUTH"
                                                                                                                                                	ExplicitAuthFlowsTypeAllowAdminUserPasswordAuth ExplicitAuthFlowsType = "ALLOW_ADMIN_USER_PASSWORD_AUTH"
                                                                                                                                                	ExplicitAuthFlowsTypeAllowCustomAuth            ExplicitAuthFlowsType = "ALLOW_CUSTOM_AUTH"
                                                                                                                                                	ExplicitAuthFlowsTypeAllowUserPasswordAuth      ExplicitAuthFlowsType = "ALLOW_USER_PASSWORD_AUTH"
                                                                                                                                                	ExplicitAuthFlowsTypeAllowUserSrpAuth           ExplicitAuthFlowsType = "ALLOW_USER_SRP_AUTH"
                                                                                                                                                	ExplicitAuthFlowsTypeAllowRefreshTokenAuth      ExplicitAuthFlowsType = "ALLOW_REFRESH_TOKEN_AUTH"
                                                                                                                                                )

                                                                                                                                                  Enum values for ExplicitAuthFlowsType

                                                                                                                                                  func (ExplicitAuthFlowsType) Values

                                                                                                                                                    Values returns all known values for ExplicitAuthFlowsType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                    type FeedbackValueType

                                                                                                                                                    type FeedbackValueType string
                                                                                                                                                    const (
                                                                                                                                                    	FeedbackValueTypeValid   FeedbackValueType = "Valid"
                                                                                                                                                    	FeedbackValueTypeInvalid FeedbackValueType = "Invalid"
                                                                                                                                                    )

                                                                                                                                                      Enum values for FeedbackValueType

                                                                                                                                                      func (FeedbackValueType) Values

                                                                                                                                                        Values returns all known values for FeedbackValueType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                        type GroupExistsException

                                                                                                                                                        type GroupExistsException struct {
                                                                                                                                                        	Message *string
                                                                                                                                                        }

                                                                                                                                                          This exception is thrown when Amazon Cognito encounters a group that already exists in the user pool.

                                                                                                                                                          func (*GroupExistsException) Error

                                                                                                                                                          func (e *GroupExistsException) Error() string

                                                                                                                                                          func (*GroupExistsException) ErrorCode

                                                                                                                                                          func (e *GroupExistsException) ErrorCode() string

                                                                                                                                                          func (*GroupExistsException) ErrorFault

                                                                                                                                                          func (e *GroupExistsException) ErrorFault() smithy.ErrorFault

                                                                                                                                                          func (*GroupExistsException) ErrorMessage

                                                                                                                                                          func (e *GroupExistsException) ErrorMessage() string

                                                                                                                                                          type GroupType

                                                                                                                                                          type GroupType struct {
                                                                                                                                                          
                                                                                                                                                          	// The date the group was created.
                                                                                                                                                          	CreationDate *time.Time
                                                                                                                                                          
                                                                                                                                                          	// A string containing the description of the group.
                                                                                                                                                          	Description *string
                                                                                                                                                          
                                                                                                                                                          	// The name of the group.
                                                                                                                                                          	GroupName *string
                                                                                                                                                          
                                                                                                                                                          	// The date the group was last modified.
                                                                                                                                                          	LastModifiedDate *time.Time
                                                                                                                                                          
                                                                                                                                                          	// A nonnegative integer value that specifies the precedence of this group relative
                                                                                                                                                          	// to the other groups that a user can belong to in the user pool. If a user
                                                                                                                                                          	// belongs to two or more groups, it is the group with the highest precedence whose
                                                                                                                                                          	// role ARN will be used in the cognito:roles and cognito:preferred_role claims in
                                                                                                                                                          	// the user's tokens. Groups with higher Precedence values take precedence over
                                                                                                                                                          	// groups with lower Precedence values or with null Precedence values. Two groups
                                                                                                                                                          	// can have the same Precedence value. If this happens, neither group takes
                                                                                                                                                          	// precedence over the other. If two groups with the same Precedence have the same
                                                                                                                                                          	// role ARN, that role is used in the cognito:preferred_role claim in tokens for
                                                                                                                                                          	// users in each group. If the two groups have different role ARNs, the
                                                                                                                                                          	// cognito:preferred_role claim is not set in users' tokens. The default Precedence
                                                                                                                                                          	// value is null.
                                                                                                                                                          	Precedence *int32
                                                                                                                                                          
                                                                                                                                                          	// The role ARN for the group.
                                                                                                                                                          	RoleArn *string
                                                                                                                                                          
                                                                                                                                                          	// The user pool ID for the user pool.
                                                                                                                                                          	UserPoolId *string
                                                                                                                                                          }

                                                                                                                                                            The group type.

                                                                                                                                                            type HttpHeader

                                                                                                                                                            type HttpHeader struct {
                                                                                                                                                            
                                                                                                                                                            	// The header name
                                                                                                                                                            	HeaderName *string
                                                                                                                                                            
                                                                                                                                                            	// The header value.
                                                                                                                                                            	HeaderValue *string
                                                                                                                                                            }

                                                                                                                                                              The HTTP header.

                                                                                                                                                              type IdentityProviderType

                                                                                                                                                              type IdentityProviderType struct {
                                                                                                                                                              
                                                                                                                                                              	// A mapping of identity provider attributes to standard and custom user pool
                                                                                                                                                              	// attributes.
                                                                                                                                                              	AttributeMapping map[string]string
                                                                                                                                                              
                                                                                                                                                              	// The date the identity provider was created.
                                                                                                                                                              	CreationDate *time.Time
                                                                                                                                                              
                                                                                                                                                              	// A list of identity provider identifiers.
                                                                                                                                                              	IdpIdentifiers []string
                                                                                                                                                              
                                                                                                                                                              	// The date the identity provider was last modified.
                                                                                                                                                              	LastModifiedDate *time.Time
                                                                                                                                                              
                                                                                                                                                              	// The identity provider details. The following list describes the provider detail
                                                                                                                                                              	// keys for each identity provider type.
                                                                                                                                                              	//
                                                                                                                                                              	// * For Google and Login with Amazon:
                                                                                                                                                              	//
                                                                                                                                                              	// *
                                                                                                                                                              	// client_id
                                                                                                                                                              	//
                                                                                                                                                              	// * client_secret
                                                                                                                                                              	//
                                                                                                                                                              	// * authorize_scopes
                                                                                                                                                              	//
                                                                                                                                                              	// * For Facebook:
                                                                                                                                                              	//
                                                                                                                                                              	// * client_id
                                                                                                                                                              	//
                                                                                                                                                              	// *
                                                                                                                                                              	// client_secret
                                                                                                                                                              	//
                                                                                                                                                              	// * authorize_scopes
                                                                                                                                                              	//
                                                                                                                                                              	// * api_version
                                                                                                                                                              	//
                                                                                                                                                              	// * For Sign in with Apple:
                                                                                                                                                              	//
                                                                                                                                                              	// *
                                                                                                                                                              	// client_id
                                                                                                                                                              	//
                                                                                                                                                              	// * team_id
                                                                                                                                                              	//
                                                                                                                                                              	// * key_id
                                                                                                                                                              	//
                                                                                                                                                              	// * private_key
                                                                                                                                                              	//
                                                                                                                                                              	// * authorize_scopes
                                                                                                                                                              	//
                                                                                                                                                              	// * For OIDC
                                                                                                                                                              	// providers:
                                                                                                                                                              	//
                                                                                                                                                              	// * client_id
                                                                                                                                                              	//
                                                                                                                                                              	// * client_secret
                                                                                                                                                              	//
                                                                                                                                                              	// * attributes_request_method
                                                                                                                                                              	//
                                                                                                                                                              	// *
                                                                                                                                                              	// oidc_issuer
                                                                                                                                                              	//
                                                                                                                                                              	// * authorize_scopes
                                                                                                                                                              	//
                                                                                                                                                              	// * authorize_url if not available from discovery
                                                                                                                                                              	// URL specified by oidc_issuer key
                                                                                                                                                              	//
                                                                                                                                                              	// * token_url if not available from discovery
                                                                                                                                                              	// URL specified by oidc_issuer key
                                                                                                                                                              	//
                                                                                                                                                              	// * attributes_url if not available from
                                                                                                                                                              	// discovery URL specified by oidc_issuer key
                                                                                                                                                              	//
                                                                                                                                                              	// * jwks_uri if not available from
                                                                                                                                                              	// discovery URL specified by oidc_issuer key
                                                                                                                                                              	//
                                                                                                                                                              	// * authorize_scopes
                                                                                                                                                              	//
                                                                                                                                                              	// * For SAML
                                                                                                                                                              	// providers:
                                                                                                                                                              	//
                                                                                                                                                              	// * MetadataFile OR MetadataURL
                                                                                                                                                              	//
                                                                                                                                                              	// * IDPSignOut optional
                                                                                                                                                              	ProviderDetails map[string]string
                                                                                                                                                              
                                                                                                                                                              	// The identity provider name.
                                                                                                                                                              	ProviderName *string
                                                                                                                                                              
                                                                                                                                                              	// The identity provider type.
                                                                                                                                                              	ProviderType IdentityProviderTypeType
                                                                                                                                                              
                                                                                                                                                              	// The user pool ID.
                                                                                                                                                              	UserPoolId *string
                                                                                                                                                              }

                                                                                                                                                                A container for information about an identity provider.

                                                                                                                                                                type IdentityProviderTypeType

                                                                                                                                                                type IdentityProviderTypeType string
                                                                                                                                                                const (
                                                                                                                                                                	IdentityProviderTypeTypeSaml            IdentityProviderTypeType = "SAML"
                                                                                                                                                                	IdentityProviderTypeTypeFacebook        IdentityProviderTypeType = "Facebook"
                                                                                                                                                                	IdentityProviderTypeTypeGoogle          IdentityProviderTypeType = "Google"
                                                                                                                                                                	IdentityProviderTypeTypeLoginWithAmazon IdentityProviderTypeType = "LoginWithAmazon"
                                                                                                                                                                	IdentityProviderTypeTypeSignInWithApple IdentityProviderTypeType = "SignInWithApple"
                                                                                                                                                                	IdentityProviderTypeTypeOidc            IdentityProviderTypeType = "OIDC"
                                                                                                                                                                )

                                                                                                                                                                  Enum values for IdentityProviderTypeType

                                                                                                                                                                  func (IdentityProviderTypeType) Values

                                                                                                                                                                    Values returns all known values for IdentityProviderTypeType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                    type InternalErrorException

                                                                                                                                                                    type InternalErrorException struct {
                                                                                                                                                                    	Message *string
                                                                                                                                                                    }

                                                                                                                                                                      This exception is thrown when Amazon Cognito encounters an internal error.

                                                                                                                                                                      func (*InternalErrorException) Error

                                                                                                                                                                      func (e *InternalErrorException) Error() string

                                                                                                                                                                      func (*InternalErrorException) ErrorCode

                                                                                                                                                                      func (e *InternalErrorException) ErrorCode() string

                                                                                                                                                                      func (*InternalErrorException) ErrorFault

                                                                                                                                                                      func (e *InternalErrorException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                      func (*InternalErrorException) ErrorMessage

                                                                                                                                                                      func (e *InternalErrorException) ErrorMessage() string

                                                                                                                                                                      type InvalidEmailRoleAccessPolicyException

                                                                                                                                                                      type InvalidEmailRoleAccessPolicyException struct {
                                                                                                                                                                      	Message *string
                                                                                                                                                                      }

                                                                                                                                                                        This exception is thrown when Amazon Cognito is not allowed to use your email identity. HTTP status code: 400.

                                                                                                                                                                        func (*InvalidEmailRoleAccessPolicyException) Error

                                                                                                                                                                        func (*InvalidEmailRoleAccessPolicyException) ErrorCode

                                                                                                                                                                        func (*InvalidEmailRoleAccessPolicyException) ErrorFault

                                                                                                                                                                        func (*InvalidEmailRoleAccessPolicyException) ErrorMessage

                                                                                                                                                                        type InvalidLambdaResponseException

                                                                                                                                                                        type InvalidLambdaResponseException struct {
                                                                                                                                                                        	Message *string
                                                                                                                                                                        }

                                                                                                                                                                          This exception is thrown when the Amazon Cognito service encounters an invalid AWS Lambda response.

                                                                                                                                                                          func (*InvalidLambdaResponseException) Error

                                                                                                                                                                          func (*InvalidLambdaResponseException) ErrorCode

                                                                                                                                                                          func (e *InvalidLambdaResponseException) ErrorCode() string

                                                                                                                                                                          func (*InvalidLambdaResponseException) ErrorFault

                                                                                                                                                                          func (*InvalidLambdaResponseException) ErrorMessage

                                                                                                                                                                          func (e *InvalidLambdaResponseException) ErrorMessage() string

                                                                                                                                                                          type InvalidOAuthFlowException

                                                                                                                                                                          type InvalidOAuthFlowException struct {
                                                                                                                                                                          	Message *string
                                                                                                                                                                          }

                                                                                                                                                                            This exception is thrown when the specified OAuth flow is invalid.

                                                                                                                                                                            func (*InvalidOAuthFlowException) Error

                                                                                                                                                                            func (e *InvalidOAuthFlowException) Error() string

                                                                                                                                                                            func (*InvalidOAuthFlowException) ErrorCode

                                                                                                                                                                            func (e *InvalidOAuthFlowException) ErrorCode() string

                                                                                                                                                                            func (*InvalidOAuthFlowException) ErrorFault

                                                                                                                                                                            func (*InvalidOAuthFlowException) ErrorMessage

                                                                                                                                                                            func (e *InvalidOAuthFlowException) ErrorMessage() string

                                                                                                                                                                            type InvalidParameterException

                                                                                                                                                                            type InvalidParameterException struct {
                                                                                                                                                                            	Message *string
                                                                                                                                                                            }

                                                                                                                                                                              This exception is thrown when the Amazon Cognito service encounters an invalid parameter.

                                                                                                                                                                              func (*InvalidParameterException) Error

                                                                                                                                                                              func (e *InvalidParameterException) Error() string

                                                                                                                                                                              func (*InvalidParameterException) ErrorCode

                                                                                                                                                                              func (e *InvalidParameterException) ErrorCode() string

                                                                                                                                                                              func (*InvalidParameterException) ErrorFault

                                                                                                                                                                              func (*InvalidParameterException) ErrorMessage

                                                                                                                                                                              func (e *InvalidParameterException) ErrorMessage() string

                                                                                                                                                                              type InvalidPasswordException

                                                                                                                                                                              type InvalidPasswordException struct {
                                                                                                                                                                              	Message *string
                                                                                                                                                                              }

                                                                                                                                                                                This exception is thrown when the Amazon Cognito service encounters an invalid password.

                                                                                                                                                                                func (*InvalidPasswordException) Error

                                                                                                                                                                                func (e *InvalidPasswordException) Error() string

                                                                                                                                                                                func (*InvalidPasswordException) ErrorCode

                                                                                                                                                                                func (e *InvalidPasswordException) ErrorCode() string

                                                                                                                                                                                func (*InvalidPasswordException) ErrorFault

                                                                                                                                                                                func (e *InvalidPasswordException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                func (*InvalidPasswordException) ErrorMessage

                                                                                                                                                                                func (e *InvalidPasswordException) ErrorMessage() string

                                                                                                                                                                                type InvalidSmsRoleAccessPolicyException

                                                                                                                                                                                type InvalidSmsRoleAccessPolicyException struct {
                                                                                                                                                                                	Message *string
                                                                                                                                                                                }

                                                                                                                                                                                  This exception is returned when the role provided for SMS configuration does not have permission to publish using Amazon SNS.

                                                                                                                                                                                  func (*InvalidSmsRoleAccessPolicyException) Error

                                                                                                                                                                                  func (*InvalidSmsRoleAccessPolicyException) ErrorCode

                                                                                                                                                                                  func (*InvalidSmsRoleAccessPolicyException) ErrorFault

                                                                                                                                                                                  func (*InvalidSmsRoleAccessPolicyException) ErrorMessage

                                                                                                                                                                                  func (e *InvalidSmsRoleAccessPolicyException) ErrorMessage() string

                                                                                                                                                                                  type InvalidSmsRoleTrustRelationshipException

                                                                                                                                                                                  type InvalidSmsRoleTrustRelationshipException struct {
                                                                                                                                                                                  	Message *string
                                                                                                                                                                                  }

                                                                                                                                                                                    This exception is thrown when the trust relationship is invalid for the role provided for SMS configuration. This can happen if you do not trust cognito-idp.amazonaws.com or the external ID provided in the role does not match what is provided in the SMS configuration for the user pool.

                                                                                                                                                                                    func (*InvalidSmsRoleTrustRelationshipException) Error

                                                                                                                                                                                    func (*InvalidSmsRoleTrustRelationshipException) ErrorCode

                                                                                                                                                                                    func (*InvalidSmsRoleTrustRelationshipException) ErrorFault

                                                                                                                                                                                    func (*InvalidSmsRoleTrustRelationshipException) ErrorMessage

                                                                                                                                                                                    type InvalidUserPoolConfigurationException

                                                                                                                                                                                    type InvalidUserPoolConfigurationException struct {
                                                                                                                                                                                    	Message *string
                                                                                                                                                                                    }

                                                                                                                                                                                      This exception is thrown when the user pool configuration is invalid.

                                                                                                                                                                                      func (*InvalidUserPoolConfigurationException) Error

                                                                                                                                                                                      func (*InvalidUserPoolConfigurationException) ErrorCode

                                                                                                                                                                                      func (*InvalidUserPoolConfigurationException) ErrorFault

                                                                                                                                                                                      func (*InvalidUserPoolConfigurationException) ErrorMessage

                                                                                                                                                                                      type LambdaConfigType

                                                                                                                                                                                      type LambdaConfigType struct {
                                                                                                                                                                                      
                                                                                                                                                                                      	// Creates an authentication challenge.
                                                                                                                                                                                      	CreateAuthChallenge *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// A custom email sender AWS Lambda trigger.
                                                                                                                                                                                      	CustomEmailSender *CustomEmailLambdaVersionConfigType
                                                                                                                                                                                      
                                                                                                                                                                                      	// A custom Message AWS Lambda trigger.
                                                                                                                                                                                      	CustomMessage *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// A custom SMS sender AWS Lambda trigger.
                                                                                                                                                                                      	CustomSMSSender *CustomSMSLambdaVersionConfigType
                                                                                                                                                                                      
                                                                                                                                                                                      	// Defines the authentication challenge.
                                                                                                                                                                                      	DefineAuthChallenge *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// The Amazon Resource Name of Key Management Service Customer master keys . Amazon
                                                                                                                                                                                      	// Cognito uses the key to encrypt codes and temporary passwords sent to
                                                                                                                                                                                      	// CustomEmailSender and CustomSMSSender.
                                                                                                                                                                                      	KMSKeyID *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// A post-authentication AWS Lambda trigger.
                                                                                                                                                                                      	PostAuthentication *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// A post-confirmation AWS Lambda trigger.
                                                                                                                                                                                      	PostConfirmation *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// A pre-authentication AWS Lambda trigger.
                                                                                                                                                                                      	PreAuthentication *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// A pre-registration AWS Lambda trigger.
                                                                                                                                                                                      	PreSignUp *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// A Lambda trigger that is invoked before token generation.
                                                                                                                                                                                      	PreTokenGeneration *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// The user migration Lambda config type.
                                                                                                                                                                                      	UserMigration *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// Verifies the authentication challenge response.
                                                                                                                                                                                      	VerifyAuthChallengeResponse *string
                                                                                                                                                                                      }

                                                                                                                                                                                        Specifies the configuration for AWS Lambda triggers.

                                                                                                                                                                                        type LimitExceededException

                                                                                                                                                                                        type LimitExceededException struct {
                                                                                                                                                                                        	Message *string
                                                                                                                                                                                        }

                                                                                                                                                                                          This exception is thrown when a user exceeds the limit for a requested AWS resource.

                                                                                                                                                                                          func (*LimitExceededException) Error

                                                                                                                                                                                          func (e *LimitExceededException) Error() string

                                                                                                                                                                                          func (*LimitExceededException) ErrorCode

                                                                                                                                                                                          func (e *LimitExceededException) ErrorCode() string

                                                                                                                                                                                          func (*LimitExceededException) ErrorFault

                                                                                                                                                                                          func (e *LimitExceededException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                          func (*LimitExceededException) ErrorMessage

                                                                                                                                                                                          func (e *LimitExceededException) ErrorMessage() string

                                                                                                                                                                                          type MFAMethodNotFoundException

                                                                                                                                                                                          type MFAMethodNotFoundException struct {
                                                                                                                                                                                          	Message *string
                                                                                                                                                                                          }

                                                                                                                                                                                            This exception is thrown when Amazon Cognito cannot find a multi-factor authentication (MFA) method.

                                                                                                                                                                                            func (*MFAMethodNotFoundException) Error

                                                                                                                                                                                            func (*MFAMethodNotFoundException) ErrorCode

                                                                                                                                                                                            func (e *MFAMethodNotFoundException) ErrorCode() string

                                                                                                                                                                                            func (*MFAMethodNotFoundException) ErrorFault

                                                                                                                                                                                            func (*MFAMethodNotFoundException) ErrorMessage

                                                                                                                                                                                            func (e *MFAMethodNotFoundException) ErrorMessage() string

                                                                                                                                                                                            type MFAOptionType

                                                                                                                                                                                            type MFAOptionType struct {
                                                                                                                                                                                            
                                                                                                                                                                                            	// The attribute name of the MFA option type. The only valid value is phone_number.
                                                                                                                                                                                            	AttributeName *string
                                                                                                                                                                                            
                                                                                                                                                                                            	// The delivery medium to send the MFA code. You can use this parameter to set only
                                                                                                                                                                                            	// the SMS delivery medium value.
                                                                                                                                                                                            	DeliveryMedium DeliveryMediumType
                                                                                                                                                                                            }

                                                                                                                                                                                              This data type is no longer supported. You can use it only for SMS MFA configurations. You can't use it for TOTP software token MFA configurations.

                                                                                                                                                                                              type MessageActionType

                                                                                                                                                                                              type MessageActionType string
                                                                                                                                                                                              const (
                                                                                                                                                                                              	MessageActionTypeResend   MessageActionType = "RESEND"
                                                                                                                                                                                              	MessageActionTypeSuppress MessageActionType = "SUPPRESS"
                                                                                                                                                                                              )

                                                                                                                                                                                                Enum values for MessageActionType

                                                                                                                                                                                                func (MessageActionType) Values

                                                                                                                                                                                                  Values returns all known values for MessageActionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                  type MessageTemplateType

                                                                                                                                                                                                  type MessageTemplateType struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The message template for email messages. EmailMessage is allowed only if
                                                                                                                                                                                                  	// EmailSendingAccount
                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_EmailConfigurationType.html#CognitoUserPools-Type-EmailConfigurationType-EmailSendingAccount)
                                                                                                                                                                                                  	// is DEVELOPER.
                                                                                                                                                                                                  	EmailMessage *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The subject line for email messages. EmailSubject is allowed only if
                                                                                                                                                                                                  	// EmailSendingAccount
                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_EmailConfigurationType.html#CognitoUserPools-Type-EmailConfigurationType-EmailSendingAccount)
                                                                                                                                                                                                  	// is DEVELOPER.
                                                                                                                                                                                                  	EmailSubject *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The message template for SMS messages.
                                                                                                                                                                                                  	SMSMessage *string
                                                                                                                                                                                                  }

                                                                                                                                                                                                    The message template structure.

                                                                                                                                                                                                    type NewDeviceMetadataType

                                                                                                                                                                                                    type NewDeviceMetadataType struct {
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The device group key.
                                                                                                                                                                                                    	DeviceGroupKey *string
                                                                                                                                                                                                    
                                                                                                                                                                                                    	// The device key.
                                                                                                                                                                                                    	DeviceKey *string
                                                                                                                                                                                                    }

                                                                                                                                                                                                      The new device metadata type.

                                                                                                                                                                                                      type NotAuthorizedException

                                                                                                                                                                                                      type NotAuthorizedException struct {
                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                      }

                                                                                                                                                                                                        This exception is thrown when a user is not authorized.

                                                                                                                                                                                                        func (*NotAuthorizedException) Error

                                                                                                                                                                                                        func (e *NotAuthorizedException) Error() string

                                                                                                                                                                                                        func (*NotAuthorizedException) ErrorCode

                                                                                                                                                                                                        func (e *NotAuthorizedException) ErrorCode() string

                                                                                                                                                                                                        func (*NotAuthorizedException) ErrorFault

                                                                                                                                                                                                        func (e *NotAuthorizedException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                        func (*NotAuthorizedException) ErrorMessage

                                                                                                                                                                                                        func (e *NotAuthorizedException) ErrorMessage() string

                                                                                                                                                                                                        type NotifyConfigurationType

                                                                                                                                                                                                        type NotifyConfigurationType struct {
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The Amazon Resource Name (ARN) of the identity that is associated with the
                                                                                                                                                                                                        	// sending authorization policy. It permits Amazon Cognito to send for the email
                                                                                                                                                                                                        	// address specified in the From parameter.
                                                                                                                                                                                                        	//
                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                        	SourceArn *string
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// Email template used when a detected risk event is blocked.
                                                                                                                                                                                                        	BlockEmail *NotifyEmailType
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The email address that is sending the email. It must be either individually
                                                                                                                                                                                                        	// verified with Amazon SES, or from a domain that has been verified with Amazon
                                                                                                                                                                                                        	// SES.
                                                                                                                                                                                                        	From *string
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The MFA email template used when MFA is challenged as part of a detected risk.
                                                                                                                                                                                                        	MfaEmail *NotifyEmailType
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The email template used when a detected risk event is allowed.
                                                                                                                                                                                                        	NoActionEmail *NotifyEmailType
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The destination to which the receiver of an email should reply to.
                                                                                                                                                                                                        	ReplyTo *string
                                                                                                                                                                                                        }

                                                                                                                                                                                                          The notify configuration type.

                                                                                                                                                                                                          type NotifyEmailType

                                                                                                                                                                                                          type NotifyEmailType struct {
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The subject.
                                                                                                                                                                                                          	//
                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                          	Subject *string
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The HTML body.
                                                                                                                                                                                                          	HtmlBody *string
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The text body.
                                                                                                                                                                                                          	TextBody *string
                                                                                                                                                                                                          }

                                                                                                                                                                                                            The notify email type.

                                                                                                                                                                                                            type NumberAttributeConstraintsType

                                                                                                                                                                                                            type NumberAttributeConstraintsType struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The maximum value of an attribute that is of the number data type.
                                                                                                                                                                                                            	MaxValue *string
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The minimum value of an attribute that is of the number data type.
                                                                                                                                                                                                            	MinValue *string
                                                                                                                                                                                                            }

                                                                                                                                                                                                              The minimum and maximum value of an attribute that is of the number data type.

                                                                                                                                                                                                              type OAuthFlowType

                                                                                                                                                                                                              type OAuthFlowType string
                                                                                                                                                                                                              const (
                                                                                                                                                                                                              	OAuthFlowTypeCode              OAuthFlowType = "code"
                                                                                                                                                                                                              	OAuthFlowTypeImplicit          OAuthFlowType = "implicit"
                                                                                                                                                                                                              	OAuthFlowTypeClientCredentials OAuthFlowType = "client_credentials"
                                                                                                                                                                                                              )

                                                                                                                                                                                                                Enum values for OAuthFlowType

                                                                                                                                                                                                                func (OAuthFlowType) Values

                                                                                                                                                                                                                func (OAuthFlowType) Values() []OAuthFlowType

                                                                                                                                                                                                                  Values returns all known values for OAuthFlowType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                  type PasswordPolicyType

                                                                                                                                                                                                                  type PasswordPolicyType struct {
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The minimum length of the password policy that you have set. Cannot be less than
                                                                                                                                                                                                                  	// 6.
                                                                                                                                                                                                                  	MinimumLength int32
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// In the password policy that you have set, refers to whether you have required
                                                                                                                                                                                                                  	// users to use at least one lowercase letter in their password.
                                                                                                                                                                                                                  	RequireLowercase bool
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// In the password policy that you have set, refers to whether you have required
                                                                                                                                                                                                                  	// users to use at least one number in their password.
                                                                                                                                                                                                                  	RequireNumbers bool
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// In the password policy that you have set, refers to whether you have required
                                                                                                                                                                                                                  	// users to use at least one symbol in their password.
                                                                                                                                                                                                                  	RequireSymbols bool
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// In the password policy that you have set, refers to whether you have required
                                                                                                                                                                                                                  	// users to use at least one uppercase letter in their password.
                                                                                                                                                                                                                  	RequireUppercase bool
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// In the password policy you have set, refers to the number of days a temporary
                                                                                                                                                                                                                  	// password is valid. If the user does not sign-in during this time, their password
                                                                                                                                                                                                                  	// will need to be reset by an administrator. When you set
                                                                                                                                                                                                                  	// TemporaryPasswordValidityDays for a user pool, you will no longer be able to set
                                                                                                                                                                                                                  	// the deprecated UnusedAccountValidityDays value for that user pool.
                                                                                                                                                                                                                  	TemporaryPasswordValidityDays int32
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    The password policy type.

                                                                                                                                                                                                                    type PasswordResetRequiredException

                                                                                                                                                                                                                    type PasswordResetRequiredException struct {
                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      This exception is thrown when a password reset is required.

                                                                                                                                                                                                                      func (*PasswordResetRequiredException) Error

                                                                                                                                                                                                                      func (*PasswordResetRequiredException) ErrorCode

                                                                                                                                                                                                                      func (e *PasswordResetRequiredException) ErrorCode() string

                                                                                                                                                                                                                      func (*PasswordResetRequiredException) ErrorFault

                                                                                                                                                                                                                      func (*PasswordResetRequiredException) ErrorMessage

                                                                                                                                                                                                                      func (e *PasswordResetRequiredException) ErrorMessage() string

                                                                                                                                                                                                                      type PreconditionNotMetException

                                                                                                                                                                                                                      type PreconditionNotMetException struct {
                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        This exception is thrown when a precondition is not met.

                                                                                                                                                                                                                        func (*PreconditionNotMetException) Error

                                                                                                                                                                                                                        func (*PreconditionNotMetException) ErrorCode

                                                                                                                                                                                                                        func (e *PreconditionNotMetException) ErrorCode() string

                                                                                                                                                                                                                        func (*PreconditionNotMetException) ErrorFault

                                                                                                                                                                                                                        func (*PreconditionNotMetException) ErrorMessage

                                                                                                                                                                                                                        func (e *PreconditionNotMetException) ErrorMessage() string

                                                                                                                                                                                                                        type PreventUserExistenceErrorTypes

                                                                                                                                                                                                                        type PreventUserExistenceErrorTypes string
                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                        	PreventUserExistenceErrorTypesLegacy  PreventUserExistenceErrorTypes = "LEGACY"
                                                                                                                                                                                                                        	PreventUserExistenceErrorTypesEnabled PreventUserExistenceErrorTypes = "ENABLED"
                                                                                                                                                                                                                        )

                                                                                                                                                                                                                          Enum values for PreventUserExistenceErrorTypes

                                                                                                                                                                                                                          func (PreventUserExistenceErrorTypes) Values

                                                                                                                                                                                                                            Values returns all known values for PreventUserExistenceErrorTypes. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                            type ProviderDescription

                                                                                                                                                                                                                            type ProviderDescription struct {
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// The date the provider was added to the user pool.
                                                                                                                                                                                                                            	CreationDate *time.Time
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// The date the provider was last modified.
                                                                                                                                                                                                                            	LastModifiedDate *time.Time
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// The identity provider name.
                                                                                                                                                                                                                            	ProviderName *string
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// The identity provider type.
                                                                                                                                                                                                                            	ProviderType IdentityProviderTypeType
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              A container for identity provider details.

                                                                                                                                                                                                                              type ProviderUserIdentifierType

                                                                                                                                                                                                                              type ProviderUserIdentifierType struct {
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The name of the provider attribute to link to, for example, NameID.
                                                                                                                                                                                                                              	ProviderAttributeName *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The value of the provider attribute to link to, for example, xxxxx_account.
                                                                                                                                                                                                                              	ProviderAttributeValue *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The name of the provider, for example, Facebook, Google, or Login with Amazon.
                                                                                                                                                                                                                              	ProviderName *string
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                A container for information about an identity provider for a user pool.

                                                                                                                                                                                                                                type RecoveryOptionNameType

                                                                                                                                                                                                                                type RecoveryOptionNameType string
                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                	RecoveryOptionNameTypeVerifiedEmail       RecoveryOptionNameType = "verified_email"
                                                                                                                                                                                                                                	RecoveryOptionNameTypeVerifiedPhoneNumber RecoveryOptionNameType = "verified_phone_number"
                                                                                                                                                                                                                                	RecoveryOptionNameTypeAdminOnly           RecoveryOptionNameType = "admin_only"
                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                  Enum values for RecoveryOptionNameType

                                                                                                                                                                                                                                  func (RecoveryOptionNameType) Values

                                                                                                                                                                                                                                    Values returns all known values for RecoveryOptionNameType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                    type RecoveryOptionType

                                                                                                                                                                                                                                    type RecoveryOptionType struct {
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// Specifies the recovery method for a user.
                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                    	Name RecoveryOptionNameType
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// A positive integer specifying priority of a method with 1 being the highest
                                                                                                                                                                                                                                    	// priority.
                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                    	Priority int32
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      A map containing a priority as a key, and recovery method name as a value.

                                                                                                                                                                                                                                      type ResourceNotFoundException

                                                                                                                                                                                                                                      type ResourceNotFoundException struct {
                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        This exception is thrown when the Amazon Cognito service cannot find the requested resource.

                                                                                                                                                                                                                                        func (*ResourceNotFoundException) Error

                                                                                                                                                                                                                                        func (e *ResourceNotFoundException) Error() string

                                                                                                                                                                                                                                        func (*ResourceNotFoundException) ErrorCode

                                                                                                                                                                                                                                        func (e *ResourceNotFoundException) ErrorCode() string

                                                                                                                                                                                                                                        func (*ResourceNotFoundException) ErrorFault

                                                                                                                                                                                                                                        func (*ResourceNotFoundException) ErrorMessage

                                                                                                                                                                                                                                        func (e *ResourceNotFoundException) ErrorMessage() string

                                                                                                                                                                                                                                        type ResourceServerScopeType

                                                                                                                                                                                                                                        type ResourceServerScopeType struct {
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// A description of the scope.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                        	ScopeDescription *string
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The name of the scope.
                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                        	ScopeName *string
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          A resource server scope.

                                                                                                                                                                                                                                          type ResourceServerType

                                                                                                                                                                                                                                          type ResourceServerType struct {
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The identifier for the resource server.
                                                                                                                                                                                                                                          	Identifier *string
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The name of the resource server.
                                                                                                                                                                                                                                          	Name *string
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// A list of scopes that are defined for the resource server.
                                                                                                                                                                                                                                          	Scopes []ResourceServerScopeType
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The user pool ID for the user pool that hosts the resource server.
                                                                                                                                                                                                                                          	UserPoolId *string
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            A container for information about a resource server for a user pool.

                                                                                                                                                                                                                                            type RiskConfigurationType

                                                                                                                                                                                                                                            type RiskConfigurationType struct {
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The account takeover risk configuration object including the NotifyConfiguration
                                                                                                                                                                                                                                            	// object and Actions to take in the case of an account takeover.
                                                                                                                                                                                                                                            	AccountTakeoverRiskConfiguration *AccountTakeoverRiskConfigurationType
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The app client ID.
                                                                                                                                                                                                                                            	ClientId *string
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The compromised credentials risk configuration object including the EventFilter
                                                                                                                                                                                                                                            	// and the EventAction
                                                                                                                                                                                                                                            	CompromisedCredentialsRiskConfiguration *CompromisedCredentialsRiskConfigurationType
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The last modified date.
                                                                                                                                                                                                                                            	LastModifiedDate *time.Time
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The configuration to override the risk decision.
                                                                                                                                                                                                                                            	RiskExceptionConfiguration *RiskExceptionConfigurationType
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// The user pool ID.
                                                                                                                                                                                                                                            	UserPoolId *string
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                              The risk configuration type.

                                                                                                                                                                                                                                              type RiskDecisionType

                                                                                                                                                                                                                                              type RiskDecisionType string
                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                              	RiskDecisionTypeNoRisk          RiskDecisionType = "NoRisk"
                                                                                                                                                                                                                                              	RiskDecisionTypeAccountTakeover RiskDecisionType = "AccountTakeover"
                                                                                                                                                                                                                                              	RiskDecisionTypeBlock           RiskDecisionType = "Block"
                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                Enum values for RiskDecisionType

                                                                                                                                                                                                                                                func (RiskDecisionType) Values

                                                                                                                                                                                                                                                  Values returns all known values for RiskDecisionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                  type RiskExceptionConfigurationType

                                                                                                                                                                                                                                                  type RiskExceptionConfigurationType struct {
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// Overrides the risk decision to always block the pre-authentication requests. The
                                                                                                                                                                                                                                                  	// IP range is in CIDR notation: a compact representation of an IP address and its
                                                                                                                                                                                                                                                  	// associated routing prefix.
                                                                                                                                                                                                                                                  	BlockedIPRangeList []string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// Risk detection is not performed on the IP addresses in the range list. The IP
                                                                                                                                                                                                                                                  	// range is in CIDR notation.
                                                                                                                                                                                                                                                  	SkippedIPRangeList []string
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    The type of the configuration to override the risk decision.

                                                                                                                                                                                                                                                    type RiskLevelType

                                                                                                                                                                                                                                                    type RiskLevelType string
                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                    	RiskLevelTypeLow    RiskLevelType = "Low"
                                                                                                                                                                                                                                                    	RiskLevelTypeMedium RiskLevelType = "Medium"
                                                                                                                                                                                                                                                    	RiskLevelTypeHigh   RiskLevelType = "High"
                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                      Enum values for RiskLevelType

                                                                                                                                                                                                                                                      func (RiskLevelType) Values

                                                                                                                                                                                                                                                      func (RiskLevelType) Values() []RiskLevelType

                                                                                                                                                                                                                                                        Values returns all known values for RiskLevelType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                        type SMSMfaSettingsType

                                                                                                                                                                                                                                                        type SMSMfaSettingsType struct {
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// Specifies whether SMS text message MFA is enabled. If an MFA type is enabled for
                                                                                                                                                                                                                                                        	// a user, the user will be prompted for MFA during all sign in attempts, unless
                                                                                                                                                                                                                                                        	// device tracking is turned on and the device has been trusted.
                                                                                                                                                                                                                                                        	Enabled bool
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// Specifies whether SMS is the preferred MFA method.
                                                                                                                                                                                                                                                        	PreferredMfa bool
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          The type used for enabling SMS MFA at the user level. Phone numbers don't need to be verified to be used for SMS MFA. If an MFA type is enabled for a user, the user will be prompted for MFA during all sign in attempts, unless device tracking is turned on and the device has been trusted. If you would like MFA to be applied selectively based on the assessed risk level of sign in attempts, disable MFA for users and turn on Adaptive Authentication for the user pool.

                                                                                                                                                                                                                                                          type SchemaAttributeType

                                                                                                                                                                                                                                                          type SchemaAttributeType struct {
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// The attribute data type.
                                                                                                                                                                                                                                                          	AttributeDataType AttributeDataType
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// We recommend that you use WriteAttributes
                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_UserPoolClientType.html#CognitoUserPools-Type-UserPoolClientType-WriteAttributes)
                                                                                                                                                                                                                                                          	// in the user pool client to control how attributes can be mutated for new use
                                                                                                                                                                                                                                                          	// cases instead of using DeveloperOnlyAttribute. Specifies whether the attribute
                                                                                                                                                                                                                                                          	// type is developer only. This attribute can only be modified by an administrator.
                                                                                                                                                                                                                                                          	// Users will not be able to modify this attribute using their access token. For
                                                                                                                                                                                                                                                          	// example, DeveloperOnlyAttribute can be modified using AdminUpdateUserAttributes
                                                                                                                                                                                                                                                          	// but cannot be updated using UpdateUserAttributes.
                                                                                                                                                                                                                                                          	DeveloperOnlyAttribute bool
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Specifies whether the value of the attribute can be changed. For any user pool
                                                                                                                                                                                                                                                          	// attribute that's mapped to an identity provider attribute, you must set this
                                                                                                                                                                                                                                                          	// parameter to true. Amazon Cognito updates mapped attributes when users sign in
                                                                                                                                                                                                                                                          	// to your application through an identity provider. If an attribute is immutable,
                                                                                                                                                                                                                                                          	// Amazon Cognito throws an error when it attempts to update the attribute. For
                                                                                                                                                                                                                                                          	// more information, see Specifying Identity Provider Attribute Mappings for Your
                                                                                                                                                                                                                                                          	// User Pool
                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-specifying-attribute-mapping.html).
                                                                                                                                                                                                                                                          	Mutable bool
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// A schema attribute of the name type.
                                                                                                                                                                                                                                                          	Name *string
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Specifies the constraints for an attribute of the number type.
                                                                                                                                                                                                                                                          	NumberAttributeConstraints *NumberAttributeConstraintsType
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Specifies whether a user pool attribute is required. If the attribute is
                                                                                                                                                                                                                                                          	// required and the user does not provide a value, registration or sign-in will
                                                                                                                                                                                                                                                          	// fail.
                                                                                                                                                                                                                                                          	Required bool
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Specifies the constraints for an attribute of the string type.
                                                                                                                                                                                                                                                          	StringAttributeConstraints *StringAttributeConstraintsType
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            Contains information about the schema attribute.

                                                                                                                                                                                                                                                            type ScopeDoesNotExistException

                                                                                                                                                                                                                                                            type ScopeDoesNotExistException struct {
                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                              This exception is thrown when the specified scope does not exist.

                                                                                                                                                                                                                                                              func (*ScopeDoesNotExistException) Error

                                                                                                                                                                                                                                                              func (*ScopeDoesNotExistException) ErrorCode

                                                                                                                                                                                                                                                              func (e *ScopeDoesNotExistException) ErrorCode() string

                                                                                                                                                                                                                                                              func (*ScopeDoesNotExistException) ErrorFault

                                                                                                                                                                                                                                                              func (*ScopeDoesNotExistException) ErrorMessage

                                                                                                                                                                                                                                                              func (e *ScopeDoesNotExistException) ErrorMessage() string

                                                                                                                                                                                                                                                              type SmsConfigurationType

                                                                                                                                                                                                                                                              type SmsConfigurationType struct {
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the Amazon Simple Notification Service (SNS)
                                                                                                                                                                                                                                                              	// caller. This is the ARN of the IAM role in your AWS account which Cognito will
                                                                                                                                                                                                                                                              	// use to send SMS messages. SMS messages are subject to a spending limit
                                                                                                                                                                                                                                                              	// (https://docs.aws.amazon.com/cognito/latest/developerguide/user-pool-settings-email-phone-verification.html).
                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                              	SnsCallerArn *string
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// The external ID is a value that we recommend you use to add security to your IAM
                                                                                                                                                                                                                                                              	// role which is used to call Amazon SNS to send SMS messages for your user pool.
                                                                                                                                                                                                                                                              	// If you provide an ExternalId, the Cognito User Pool will include it when
                                                                                                                                                                                                                                                              	// attempting to assume your IAM role, so that you can set your roles trust policy
                                                                                                                                                                                                                                                              	// to require the ExternalID. If you use the Cognito Management Console to create a
                                                                                                                                                                                                                                                              	// role for SMS MFA, Cognito will create a role with the required permissions and a
                                                                                                                                                                                                                                                              	// trust policy that demonstrates use of the ExternalId.
                                                                                                                                                                                                                                                              	ExternalId *string
                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                The SMS configuration type that includes the settings the Cognito User Pool needs to call for the Amazon SNS service to send an SMS message from your AWS account. The Cognito User Pool makes the request to the Amazon SNS Service by using an AWS IAM role that you provide for your AWS account.

                                                                                                                                                                                                                                                                type SmsMfaConfigType

                                                                                                                                                                                                                                                                type SmsMfaConfigType struct {
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The SMS authentication message that will be sent to users with the code they
                                                                                                                                                                                                                                                                	// need to sign in. The message must contain the ‘{####}’ placeholder, which will
                                                                                                                                                                                                                                                                	// be replaced with the code. If the message is not included, and default message
                                                                                                                                                                                                                                                                	// will be used.
                                                                                                                                                                                                                                                                	SmsAuthenticationMessage *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The SMS configuration.
                                                                                                                                                                                                                                                                	SmsConfiguration *SmsConfigurationType
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                  The SMS text message multi-factor authentication (MFA) configuration type.

                                                                                                                                                                                                                                                                  type SoftwareTokenMFANotFoundException

                                                                                                                                                                                                                                                                  type SoftwareTokenMFANotFoundException struct {
                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                    This exception is thrown when the software token TOTP multi-factor authentication (MFA) is not enabled for the user pool.

                                                                                                                                                                                                                                                                    func (*SoftwareTokenMFANotFoundException) Error

                                                                                                                                                                                                                                                                    func (*SoftwareTokenMFANotFoundException) ErrorCode

                                                                                                                                                                                                                                                                    func (*SoftwareTokenMFANotFoundException) ErrorFault

                                                                                                                                                                                                                                                                    func (*SoftwareTokenMFANotFoundException) ErrorMessage

                                                                                                                                                                                                                                                                    func (e *SoftwareTokenMFANotFoundException) ErrorMessage() string

                                                                                                                                                                                                                                                                    type SoftwareTokenMfaConfigType

                                                                                                                                                                                                                                                                    type SoftwareTokenMfaConfigType struct {
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// Specifies whether software token MFA is enabled.
                                                                                                                                                                                                                                                                    	Enabled bool
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      The type used for enabling software token MFA at the user pool level.

                                                                                                                                                                                                                                                                      type SoftwareTokenMfaSettingsType

                                                                                                                                                                                                                                                                      type SoftwareTokenMfaSettingsType struct {
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// Specifies whether software token MFA is enabled. If an MFA type is enabled for a
                                                                                                                                                                                                                                                                      	// user, the user will be prompted for MFA during all sign in attempts, unless
                                                                                                                                                                                                                                                                      	// device tracking is turned on and the device has been trusted.
                                                                                                                                                                                                                                                                      	Enabled bool
                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                      	// Specifies whether software token MFA is the preferred MFA method.
                                                                                                                                                                                                                                                                      	PreferredMfa bool
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                        The type used for enabling software token MFA at the user level. If an MFA type is enabled for a user, the user will be prompted for MFA during all sign in attempts, unless device tracking is turned on and the device has been trusted. If you would like MFA to be applied selectively based on the assessed risk level of sign in attempts, disable MFA for users and turn on Adaptive Authentication for the user pool.

                                                                                                                                                                                                                                                                        type StatusType

                                                                                                                                                                                                                                                                        type StatusType string
                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                        	StatusTypeEnabled  StatusType = "Enabled"
                                                                                                                                                                                                                                                                        	StatusTypeDisabled StatusType = "Disabled"
                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                          Enum values for StatusType

                                                                                                                                                                                                                                                                          func (StatusType) Values

                                                                                                                                                                                                                                                                          func (StatusType) Values() []StatusType

                                                                                                                                                                                                                                                                            Values returns all known values for StatusType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                            type StringAttributeConstraintsType

                                                                                                                                                                                                                                                                            type StringAttributeConstraintsType struct {
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// The maximum length.
                                                                                                                                                                                                                                                                            	MaxLength *string
                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                            	// The minimum length.
                                                                                                                                                                                                                                                                            	MinLength *string
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              The constraints associated with a string attribute.

                                                                                                                                                                                                                                                                              type TimeUnitsType

                                                                                                                                                                                                                                                                              type TimeUnitsType string
                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                              	TimeUnitsTypeSeconds TimeUnitsType = "seconds"
                                                                                                                                                                                                                                                                              	TimeUnitsTypeMinutes TimeUnitsType = "minutes"
                                                                                                                                                                                                                                                                              	TimeUnitsTypeHours   TimeUnitsType = "hours"
                                                                                                                                                                                                                                                                              	TimeUnitsTypeDays    TimeUnitsType = "days"
                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                Enum values for TimeUnitsType

                                                                                                                                                                                                                                                                                func (TimeUnitsType) Values

                                                                                                                                                                                                                                                                                func (TimeUnitsType) Values() []TimeUnitsType

                                                                                                                                                                                                                                                                                  Values returns all known values for TimeUnitsType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                  type TokenValidityUnitsType

                                                                                                                                                                                                                                                                                  type TokenValidityUnitsType struct {
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// A time unit in “seconds”, “minutes”, “hours” or “days” for the value in
                                                                                                                                                                                                                                                                                  	// AccessTokenValidity, defaults to hours.
                                                                                                                                                                                                                                                                                  	AccessToken TimeUnitsType
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// A time unit in “seconds”, “minutes”, “hours” or “days” for the value in
                                                                                                                                                                                                                                                                                  	// IdTokenValidity, defaults to hours.
                                                                                                                                                                                                                                                                                  	IdToken TimeUnitsType
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// A time unit in “seconds”, “minutes”, “hours” or “days” for the value in
                                                                                                                                                                                                                                                                                  	// RefreshTokenValidity, defaults to days.
                                                                                                                                                                                                                                                                                  	RefreshToken TimeUnitsType
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    The data type for TokenValidityUnits that specifics the time measurements for token validity.

                                                                                                                                                                                                                                                                                    type TooManyFailedAttemptsException

                                                                                                                                                                                                                                                                                    type TooManyFailedAttemptsException struct {
                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                      This exception is thrown when the user has made too many failed attempts for a given action (e.g., sign in).

                                                                                                                                                                                                                                                                                      func (*TooManyFailedAttemptsException) Error

                                                                                                                                                                                                                                                                                      func (*TooManyFailedAttemptsException) ErrorCode

                                                                                                                                                                                                                                                                                      func (e *TooManyFailedAttemptsException) ErrorCode() string

                                                                                                                                                                                                                                                                                      func (*TooManyFailedAttemptsException) ErrorFault

                                                                                                                                                                                                                                                                                      func (*TooManyFailedAttemptsException) ErrorMessage

                                                                                                                                                                                                                                                                                      func (e *TooManyFailedAttemptsException) ErrorMessage() string

                                                                                                                                                                                                                                                                                      type TooManyRequestsException

                                                                                                                                                                                                                                                                                      type TooManyRequestsException struct {
                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        This exception is thrown when the user has made too many requests for a given operation.

                                                                                                                                                                                                                                                                                        func (*TooManyRequestsException) Error

                                                                                                                                                                                                                                                                                        func (e *TooManyRequestsException) Error() string

                                                                                                                                                                                                                                                                                        func (*TooManyRequestsException) ErrorCode

                                                                                                                                                                                                                                                                                        func (e *TooManyRequestsException) ErrorCode() string

                                                                                                                                                                                                                                                                                        func (*TooManyRequestsException) ErrorFault

                                                                                                                                                                                                                                                                                        func (e *TooManyRequestsException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                        func (*TooManyRequestsException) ErrorMessage

                                                                                                                                                                                                                                                                                        func (e *TooManyRequestsException) ErrorMessage() string

                                                                                                                                                                                                                                                                                        type UICustomizationType

                                                                                                                                                                                                                                                                                        type UICustomizationType struct {
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The CSS values in the UI customization.
                                                                                                                                                                                                                                                                                        	CSS *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The CSS version number.
                                                                                                                                                                                                                                                                                        	CSSVersion *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The client ID for the client app.
                                                                                                                                                                                                                                                                                        	ClientId *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The creation date for the UI customization.
                                                                                                                                                                                                                                                                                        	CreationDate *time.Time
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The logo image for the UI customization.
                                                                                                                                                                                                                                                                                        	ImageUrl *string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The last-modified date for the UI customization.
                                                                                                                                                                                                                                                                                        	LastModifiedDate *time.Time
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	// The user pool ID for the user pool.
                                                                                                                                                                                                                                                                                        	UserPoolId *string
                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                          A container for the UI customization information for a user pool's built-in app UI.

                                                                                                                                                                                                                                                                                          type UnexpectedLambdaException

                                                                                                                                                                                                                                                                                          type UnexpectedLambdaException struct {
                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                            This exception is thrown when the Amazon Cognito service encounters an unexpected exception with the AWS Lambda service.

                                                                                                                                                                                                                                                                                            func (*UnexpectedLambdaException) Error

                                                                                                                                                                                                                                                                                            func (e *UnexpectedLambdaException) Error() string

                                                                                                                                                                                                                                                                                            func (*UnexpectedLambdaException) ErrorCode

                                                                                                                                                                                                                                                                                            func (e *UnexpectedLambdaException) ErrorCode() string

                                                                                                                                                                                                                                                                                            func (*UnexpectedLambdaException) ErrorFault

                                                                                                                                                                                                                                                                                            func (*UnexpectedLambdaException) ErrorMessage

                                                                                                                                                                                                                                                                                            func (e *UnexpectedLambdaException) ErrorMessage() string

                                                                                                                                                                                                                                                                                            type UnsupportedIdentityProviderException

                                                                                                                                                                                                                                                                                            type UnsupportedIdentityProviderException struct {
                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                              This exception is thrown when the specified identifier is not supported.

                                                                                                                                                                                                                                                                                              func (*UnsupportedIdentityProviderException) Error

                                                                                                                                                                                                                                                                                              func (*UnsupportedIdentityProviderException) ErrorCode

                                                                                                                                                                                                                                                                                              func (*UnsupportedIdentityProviderException) ErrorFault

                                                                                                                                                                                                                                                                                              func (*UnsupportedIdentityProviderException) ErrorMessage

                                                                                                                                                                                                                                                                                              func (e *UnsupportedIdentityProviderException) ErrorMessage() string

                                                                                                                                                                                                                                                                                              type UnsupportedUserStateException

                                                                                                                                                                                                                                                                                              type UnsupportedUserStateException struct {
                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                The request failed because the user is in an unsupported state.

                                                                                                                                                                                                                                                                                                func (*UnsupportedUserStateException) Error

                                                                                                                                                                                                                                                                                                func (*UnsupportedUserStateException) ErrorCode

                                                                                                                                                                                                                                                                                                func (e *UnsupportedUserStateException) ErrorCode() string

                                                                                                                                                                                                                                                                                                func (*UnsupportedUserStateException) ErrorFault

                                                                                                                                                                                                                                                                                                func (*UnsupportedUserStateException) ErrorMessage

                                                                                                                                                                                                                                                                                                func (e *UnsupportedUserStateException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                type UserContextDataType

                                                                                                                                                                                                                                                                                                type UserContextDataType struct {
                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                	// Contextual data such as the user's device fingerprint, IP address, or location
                                                                                                                                                                                                                                                                                                	// used for evaluating the risk of an unexpected event by Amazon Cognito advanced
                                                                                                                                                                                                                                                                                                	// security.
                                                                                                                                                                                                                                                                                                	EncodedData *string
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                  Contextual data such as the user's device fingerprint, IP address, or location used for evaluating the risk of an unexpected event by Amazon Cognito advanced security.

                                                                                                                                                                                                                                                                                                  type UserImportInProgressException

                                                                                                                                                                                                                                                                                                  type UserImportInProgressException struct {
                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                    This exception is thrown when you are trying to modify a user pool while a user import job is in progress for that pool.

                                                                                                                                                                                                                                                                                                    func (*UserImportInProgressException) Error

                                                                                                                                                                                                                                                                                                    func (*UserImportInProgressException) ErrorCode

                                                                                                                                                                                                                                                                                                    func (e *UserImportInProgressException) ErrorCode() string

                                                                                                                                                                                                                                                                                                    func (*UserImportInProgressException) ErrorFault

                                                                                                                                                                                                                                                                                                    func (*UserImportInProgressException) ErrorMessage

                                                                                                                                                                                                                                                                                                    func (e *UserImportInProgressException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                    type UserImportJobStatusType

                                                                                                                                                                                                                                                                                                    type UserImportJobStatusType string
                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                    	UserImportJobStatusTypeCreated    UserImportJobStatusType = "Created"
                                                                                                                                                                                                                                                                                                    	UserImportJobStatusTypePending    UserImportJobStatusType = "Pending"
                                                                                                                                                                                                                                                                                                    	UserImportJobStatusTypeInProgress UserImportJobStatusType = "InProgress"
                                                                                                                                                                                                                                                                                                    	UserImportJobStatusTypeStopping   UserImportJobStatusType = "Stopping"
                                                                                                                                                                                                                                                                                                    	UserImportJobStatusTypeExpired    UserImportJobStatusType = "Expired"
                                                                                                                                                                                                                                                                                                    	UserImportJobStatusTypeStopped    UserImportJobStatusType = "Stopped"
                                                                                                                                                                                                                                                                                                    	UserImportJobStatusTypeFailed     UserImportJobStatusType = "Failed"
                                                                                                                                                                                                                                                                                                    	UserImportJobStatusTypeSucceeded  UserImportJobStatusType = "Succeeded"
                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                      Enum values for UserImportJobStatusType

                                                                                                                                                                                                                                                                                                      func (UserImportJobStatusType) Values

                                                                                                                                                                                                                                                                                                        Values returns all known values for UserImportJobStatusType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                        type UserImportJobType

                                                                                                                                                                                                                                                                                                        type UserImportJobType struct {
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The role ARN for the Amazon CloudWatch Logging role for the user import job. For
                                                                                                                                                                                                                                                                                                        	// more information, see "Creating the CloudWatch Logs IAM Role" in the Amazon
                                                                                                                                                                                                                                                                                                        	// Cognito Developer Guide.
                                                                                                                                                                                                                                                                                                        	CloudWatchLogsRoleArn *string
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The date when the user import job was completed.
                                                                                                                                                                                                                                                                                                        	CompletionDate *time.Time
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The message returned when the user import job is completed.
                                                                                                                                                                                                                                                                                                        	CompletionMessage *string
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The date the user import job was created.
                                                                                                                                                                                                                                                                                                        	CreationDate *time.Time
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The number of users that could not be imported.
                                                                                                                                                                                                                                                                                                        	FailedUsers int64
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The number of users that were successfully imported.
                                                                                                                                                                                                                                                                                                        	ImportedUsers int64
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The job ID for the user import job.
                                                                                                                                                                                                                                                                                                        	JobId *string
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The job name for the user import job.
                                                                                                                                                                                                                                                                                                        	JobName *string
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The pre-signed URL to be used to upload the .csv file.
                                                                                                                                                                                                                                                                                                        	PreSignedUrl *string
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The number of users that were skipped.
                                                                                                                                                                                                                                                                                                        	SkippedUsers int64
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The date when the user import job was started.
                                                                                                                                                                                                                                                                                                        	StartDate *time.Time
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The status of the user import job. One of the following:
                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                        	// * Created - The job
                                                                                                                                                                                                                                                                                                        	// was created but not started.
                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                        	// * Pending - A transition state. You have started
                                                                                                                                                                                                                                                                                                        	// the job, but it has not begun importing users yet.
                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                        	// * InProgress - The job has
                                                                                                                                                                                                                                                                                                        	// started, and users are being imported.
                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                        	// * Stopping - You have stopped the job,
                                                                                                                                                                                                                                                                                                        	// but the job has not stopped importing users yet.
                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                        	// * Stopped - You have stopped
                                                                                                                                                                                                                                                                                                        	// the job, and the job has stopped importing users.
                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                        	// * Succeeded - The job has
                                                                                                                                                                                                                                                                                                        	// completed successfully.
                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                        	// * Failed - The job has stopped due to an error.
                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                        	// *
                                                                                                                                                                                                                                                                                                        	// Expired - You created a job, but did not start the job within 24-48 hours. All
                                                                                                                                                                                                                                                                                                        	// data associated with the job was deleted, and the job cannot be started.
                                                                                                                                                                                                                                                                                                        	Status UserImportJobStatusType
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// The user pool ID for the user pool that the users are being imported into.
                                                                                                                                                                                                                                                                                                        	UserPoolId *string
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          The user import job type.

                                                                                                                                                                                                                                                                                                          type UserLambdaValidationException

                                                                                                                                                                                                                                                                                                          type UserLambdaValidationException struct {
                                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                            This exception is thrown when the Amazon Cognito service encounters a user validation exception with the AWS Lambda service.

                                                                                                                                                                                                                                                                                                            func (*UserLambdaValidationException) Error

                                                                                                                                                                                                                                                                                                            func (*UserLambdaValidationException) ErrorCode

                                                                                                                                                                                                                                                                                                            func (e *UserLambdaValidationException) ErrorCode() string

                                                                                                                                                                                                                                                                                                            func (*UserLambdaValidationException) ErrorFault

                                                                                                                                                                                                                                                                                                            func (*UserLambdaValidationException) ErrorMessage

                                                                                                                                                                                                                                                                                                            func (e *UserLambdaValidationException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                            type UserNotConfirmedException

                                                                                                                                                                                                                                                                                                            type UserNotConfirmedException struct {
                                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                              This exception is thrown when a user is not confirmed successfully.

                                                                                                                                                                                                                                                                                                              func (*UserNotConfirmedException) Error

                                                                                                                                                                                                                                                                                                              func (e *UserNotConfirmedException) Error() string

                                                                                                                                                                                                                                                                                                              func (*UserNotConfirmedException) ErrorCode

                                                                                                                                                                                                                                                                                                              func (e *UserNotConfirmedException) ErrorCode() string

                                                                                                                                                                                                                                                                                                              func (*UserNotConfirmedException) ErrorFault

                                                                                                                                                                                                                                                                                                              func (*UserNotConfirmedException) ErrorMessage

                                                                                                                                                                                                                                                                                                              func (e *UserNotConfirmedException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                              type UserNotFoundException

                                                                                                                                                                                                                                                                                                              type UserNotFoundException struct {
                                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                This exception is thrown when a user is not found.

                                                                                                                                                                                                                                                                                                                func (*UserNotFoundException) Error

                                                                                                                                                                                                                                                                                                                func (e *UserNotFoundException) Error() string

                                                                                                                                                                                                                                                                                                                func (*UserNotFoundException) ErrorCode

                                                                                                                                                                                                                                                                                                                func (e *UserNotFoundException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                func (*UserNotFoundException) ErrorFault

                                                                                                                                                                                                                                                                                                                func (e *UserNotFoundException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                func (*UserNotFoundException) ErrorMessage

                                                                                                                                                                                                                                                                                                                func (e *UserNotFoundException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                type UserPoolAddOnNotEnabledException

                                                                                                                                                                                                                                                                                                                type UserPoolAddOnNotEnabledException struct {
                                                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                  This exception is thrown when user pool add-ons are not enabled.

                                                                                                                                                                                                                                                                                                                  func (*UserPoolAddOnNotEnabledException) Error

                                                                                                                                                                                                                                                                                                                  func (*UserPoolAddOnNotEnabledException) ErrorCode

                                                                                                                                                                                                                                                                                                                  func (*UserPoolAddOnNotEnabledException) ErrorFault

                                                                                                                                                                                                                                                                                                                  func (*UserPoolAddOnNotEnabledException) ErrorMessage

                                                                                                                                                                                                                                                                                                                  func (e *UserPoolAddOnNotEnabledException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                  type UserPoolAddOnsType

                                                                                                                                                                                                                                                                                                                  type UserPoolAddOnsType struct {
                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                  	// The advanced security mode.
                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                                                  	AdvancedSecurityMode AdvancedSecurityModeType
                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                    The user pool add-ons type.

                                                                                                                                                                                                                                                                                                                    type UserPoolClientDescription

                                                                                                                                                                                                                                                                                                                    type UserPoolClientDescription struct {
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// The ID of the client associated with the user pool.
                                                                                                                                                                                                                                                                                                                    	ClientId *string
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// The client name from the user pool client description.
                                                                                                                                                                                                                                                                                                                    	ClientName *string
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	// The user pool ID for the user pool where you want to describe the user pool
                                                                                                                                                                                                                                                                                                                    	// client.
                                                                                                                                                                                                                                                                                                                    	UserPoolId *string
                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                      The description of the user pool client.

                                                                                                                                                                                                                                                                                                                      type UserPoolClientType

                                                                                                                                                                                                                                                                                                                      type UserPoolClientType struct {
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The time limit, specified by tokenValidityUnits, defaulting to hours, after
                                                                                                                                                                                                                                                                                                                      	// which the access token is no longer valid and cannot be used.
                                                                                                                                                                                                                                                                                                                      	AccessTokenValidity *int32
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The allowed OAuth flows. Set to code to initiate a code grant flow, which
                                                                                                                                                                                                                                                                                                                      	// provides an authorization code as the response. This code can be exchanged for
                                                                                                                                                                                                                                                                                                                      	// access tokens with the token endpoint. Set to implicit to specify that the
                                                                                                                                                                                                                                                                                                                      	// client should get the access token (and, optionally, ID token, based on scopes)
                                                                                                                                                                                                                                                                                                                      	// directly. Set to client_credentials to specify that the client should get the
                                                                                                                                                                                                                                                                                                                      	// access token (and, optionally, ID token, based on scopes) from the token
                                                                                                                                                                                                                                                                                                                      	// endpoint using a combination of client and client_secret.
                                                                                                                                                                                                                                                                                                                      	AllowedOAuthFlows []OAuthFlowType
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// Set to true if the client is allowed to follow the OAuth protocol when
                                                                                                                                                                                                                                                                                                                      	// interacting with Cognito user pools.
                                                                                                                                                                                                                                                                                                                      	AllowedOAuthFlowsUserPoolClient bool
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The allowed OAuth scopes. Possible values provided by OAuth are: phone, email,
                                                                                                                                                                                                                                                                                                                      	// openid, and profile. Possible values provided by AWS are:
                                                                                                                                                                                                                                                                                                                      	// aws.cognito.signin.user.admin. Custom scopes created in Resource Servers are
                                                                                                                                                                                                                                                                                                                      	// also supported.
                                                                                                                                                                                                                                                                                                                      	AllowedOAuthScopes []string
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The Amazon Pinpoint analytics configuration for the user pool client. Cognito
                                                                                                                                                                                                                                                                                                                      	// User Pools only supports sending events to Amazon Pinpoint projects in the US
                                                                                                                                                                                                                                                                                                                      	// East (N. Virginia) us-east-1 Region, regardless of the region in which the user
                                                                                                                                                                                                                                                                                                                      	// pool resides.
                                                                                                                                                                                                                                                                                                                      	AnalyticsConfiguration *AnalyticsConfigurationType
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// A list of allowed redirect (callback) URLs for the identity providers. A
                                                                                                                                                                                                                                                                                                                      	// redirect URI must:
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// * Be an absolute URI.
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// * Be registered with the
                                                                                                                                                                                                                                                                                                                      	// authorization server.
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// * Not include a fragment component.
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// See OAuth 2.0 -
                                                                                                                                                                                                                                                                                                                      	// Redirection Endpoint (https://tools.ietf.org/html/rfc6749#section-3.1.2). Amazon
                                                                                                                                                                                                                                                                                                                      	// Cognito requires HTTPS over HTTP except for http://localhost for testing
                                                                                                                                                                                                                                                                                                                      	// purposes only. App callback URLs such as myapp://example are also supported.
                                                                                                                                                                                                                                                                                                                      	CallbackURLs []string
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The ID of the client associated with the user pool.
                                                                                                                                                                                                                                                                                                                      	ClientId *string
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The client name from the user pool request of the client type.
                                                                                                                                                                                                                                                                                                                      	ClientName *string
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The client secret from the user pool request of the client type.
                                                                                                                                                                                                                                                                                                                      	ClientSecret *string
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The date the user pool client was created.
                                                                                                                                                                                                                                                                                                                      	CreationDate *time.Time
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The default redirect URI. Must be in the CallbackURLs list. A redirect URI
                                                                                                                                                                                                                                                                                                                      	// must:
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// * Be an absolute URI.
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// * Be registered with the authorization server.
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// *
                                                                                                                                                                                                                                                                                                                      	// Not include a fragment component.
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// See OAuth 2.0 - Redirection Endpoint
                                                                                                                                                                                                                                                                                                                      	// (https://tools.ietf.org/html/rfc6749#section-3.1.2). Amazon Cognito requires
                                                                                                                                                                                                                                                                                                                      	// HTTPS over HTTP except for http://localhost for testing purposes only. App
                                                                                                                                                                                                                                                                                                                      	// callback URLs such as myapp://example are also supported.
                                                                                                                                                                                                                                                                                                                      	DefaultRedirectURI *string
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The authentication flows that are supported by the user pool clients. Flow names
                                                                                                                                                                                                                                                                                                                      	// without the ALLOW_ prefix are deprecated in favor of new names with the ALLOW_
                                                                                                                                                                                                                                                                                                                      	// prefix. Note that values with ALLOW_ prefix cannot be used along with values
                                                                                                                                                                                                                                                                                                                      	// without ALLOW_ prefix. Valid values include:
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// * ALLOW_ADMIN_USER_PASSWORD_AUTH:
                                                                                                                                                                                                                                                                                                                      	// Enable admin based user password authentication flow ADMIN_USER_PASSWORD_AUTH.
                                                                                                                                                                                                                                                                                                                      	// This setting replaces the ADMIN_NO_SRP_AUTH setting. With this authentication
                                                                                                                                                                                                                                                                                                                      	// flow, Cognito receives the password in the request instead of using the SRP
                                                                                                                                                                                                                                                                                                                      	// (Secure Remote Password protocol) protocol to verify passwords.
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// *
                                                                                                                                                                                                                                                                                                                      	// ALLOW_CUSTOM_AUTH: Enable Lambda trigger based authentication.
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// *
                                                                                                                                                                                                                                                                                                                      	// ALLOW_USER_PASSWORD_AUTH: Enable user password-based authentication. In this
                                                                                                                                                                                                                                                                                                                      	// flow, Cognito receives the password in the request instead of using the SRP
                                                                                                                                                                                                                                                                                                                      	// protocol to verify passwords.
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// * ALLOW_USER_SRP_AUTH: Enable SRP based
                                                                                                                                                                                                                                                                                                                      	// authentication.
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// * ALLOW_REFRESH_TOKEN_AUTH: Enable authflow to refresh tokens.
                                                                                                                                                                                                                                                                                                                      	ExplicitAuthFlows []ExplicitAuthFlowsType
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The time limit, specified by tokenValidityUnits, defaulting to hours, after
                                                                                                                                                                                                                                                                                                                      	// which the refresh token is no longer valid and cannot be used.
                                                                                                                                                                                                                                                                                                                      	IdTokenValidity *int32
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The date the user pool client was last modified.
                                                                                                                                                                                                                                                                                                                      	LastModifiedDate *time.Time
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// A list of allowed logout URLs for the identity providers.
                                                                                                                                                                                                                                                                                                                      	LogoutURLs []string
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// Use this setting to choose which errors and responses are returned by Cognito
                                                                                                                                                                                                                                                                                                                      	// APIs during authentication, account confirmation, and password recovery when the
                                                                                                                                                                                                                                                                                                                      	// user does not exist in the user pool. When set to ENABLED and the user does not
                                                                                                                                                                                                                                                                                                                      	// exist, authentication returns an error indicating either the username or
                                                                                                                                                                                                                                                                                                                      	// password was incorrect, and account confirmation and password recovery return a
                                                                                                                                                                                                                                                                                                                      	// response indicating a code was sent to a simulated destination. When set to
                                                                                                                                                                                                                                                                                                                      	// LEGACY, those APIs will return a UserNotFoundException exception if the user
                                                                                                                                                                                                                                                                                                                      	// does not exist in the user pool. Valid values include:
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// * ENABLED - This
                                                                                                                                                                                                                                                                                                                      	// prevents user existence-related errors.
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// * LEGACY - This represents the old
                                                                                                                                                                                                                                                                                                                      	// behavior of Cognito where user existence related errors are not
                                                                                                                                                                                                                                                                                                                      	// prevented.
                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                      	// After February 15th 2020, the value of PreventUserExistenceErrors
                                                                                                                                                                                                                                                                                                                      	// will default to ENABLED for newly created user pool clients if no value is
                                                                                                                                                                                                                                                                                                                      	// provided.
                                                                                                                                                                                                                                                                                                                      	PreventUserExistenceErrors PreventUserExistenceErrorTypes
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The Read-only attributes.
                                                                                                                                                                                                                                                                                                                      	ReadAttributes []string
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The time limit, in days, after which the refresh token is no longer valid and
                                                                                                                                                                                                                                                                                                                      	// cannot be used.
                                                                                                                                                                                                                                                                                                                      	RefreshTokenValidity int32
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// A list of provider names for the identity providers that are supported on this
                                                                                                                                                                                                                                                                                                                      	// client.
                                                                                                                                                                                                                                                                                                                      	SupportedIdentityProviders []string
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The time units used to specify the token validity times of their respective
                                                                                                                                                                                                                                                                                                                      	// token.
                                                                                                                                                                                                                                                                                                                      	TokenValidityUnits *TokenValidityUnitsType
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The user pool ID for the user pool client.
                                                                                                                                                                                                                                                                                                                      	UserPoolId *string
                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                      	// The writeable attributes.
                                                                                                                                                                                                                                                                                                                      	WriteAttributes []string
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                        Contains information about a user pool client.

                                                                                                                                                                                                                                                                                                                        type UserPoolDescriptionType

                                                                                                                                                                                                                                                                                                                        type UserPoolDescriptionType struct {
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The date the user pool description was created.
                                                                                                                                                                                                                                                                                                                        	CreationDate *time.Time
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The ID in a user pool description.
                                                                                                                                                                                                                                                                                                                        	Id *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The AWS Lambda configuration information in a user pool description.
                                                                                                                                                                                                                                                                                                                        	LambdaConfig *LambdaConfigType
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The date the user pool description was last modified.
                                                                                                                                                                                                                                                                                                                        	LastModifiedDate *time.Time
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The name in a user pool description.
                                                                                                                                                                                                                                                                                                                        	Name *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The user pool status in a user pool description.
                                                                                                                                                                                                                                                                                                                        	Status StatusType
                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                          A user pool description.

                                                                                                                                                                                                                                                                                                                          type UserPoolMfaType

                                                                                                                                                                                                                                                                                                                          type UserPoolMfaType string
                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                          	UserPoolMfaTypeOff      UserPoolMfaType = "OFF"
                                                                                                                                                                                                                                                                                                                          	UserPoolMfaTypeOn       UserPoolMfaType = "ON"
                                                                                                                                                                                                                                                                                                                          	UserPoolMfaTypeOptional UserPoolMfaType = "OPTIONAL"
                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                            Enum values for UserPoolMfaType

                                                                                                                                                                                                                                                                                                                            func (UserPoolMfaType) Values

                                                                                                                                                                                                                                                                                                                            func (UserPoolMfaType) Values() []UserPoolMfaType

                                                                                                                                                                                                                                                                                                                              Values returns all known values for UserPoolMfaType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                              type UserPoolPolicyType

                                                                                                                                                                                                                                                                                                                              type UserPoolPolicyType struct {
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// The password policy.
                                                                                                                                                                                                                                                                                                                              	PasswordPolicy *PasswordPolicyType
                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                The policy associated with a user pool.

                                                                                                                                                                                                                                                                                                                                type UserPoolTaggingException

                                                                                                                                                                                                                                                                                                                                type UserPoolTaggingException struct {
                                                                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                  This exception is thrown when a user pool tag cannot be set or updated.

                                                                                                                                                                                                                                                                                                                                  func (*UserPoolTaggingException) Error

                                                                                                                                                                                                                                                                                                                                  func (e *UserPoolTaggingException) Error() string

                                                                                                                                                                                                                                                                                                                                  func (*UserPoolTaggingException) ErrorCode

                                                                                                                                                                                                                                                                                                                                  func (e *UserPoolTaggingException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                  func (*UserPoolTaggingException) ErrorFault

                                                                                                                                                                                                                                                                                                                                  func (e *UserPoolTaggingException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                                  func (*UserPoolTaggingException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                  func (e *UserPoolTaggingException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                  type UserPoolType

                                                                                                                                                                                                                                                                                                                                  type UserPoolType struct {
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Use this setting to define which verified available method a user can use to
                                                                                                                                                                                                                                                                                                                                  	// recover their password when they call ForgotPassword. It allows you to define a
                                                                                                                                                                                                                                                                                                                                  	// preferred method when a user has more than one method available. With this
                                                                                                                                                                                                                                                                                                                                  	// setting, SMS does not qualify for a valid password recovery mechanism if the
                                                                                                                                                                                                                                                                                                                                  	// user also has SMS MFA enabled. In the absence of this setting, Cognito uses the
                                                                                                                                                                                                                                                                                                                                  	// legacy behavior to determine the recovery method where SMS is preferred over
                                                                                                                                                                                                                                                                                                                                  	// email.
                                                                                                                                                                                                                                                                                                                                  	AccountRecoverySetting *AccountRecoverySettingType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The configuration for AdminCreateUser requests.
                                                                                                                                                                                                                                                                                                                                  	AdminCreateUserConfig *AdminCreateUserConfigType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Specifies the attributes that are aliased in a user pool.
                                                                                                                                                                                                                                                                                                                                  	AliasAttributes []AliasAttributeType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The Amazon Resource Name (ARN) for the user pool.
                                                                                                                                                                                                                                                                                                                                  	Arn *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Specifies the attributes that are auto-verified in a user pool.
                                                                                                                                                                                                                                                                                                                                  	AutoVerifiedAttributes []VerifiedAttributeType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The date the user pool was created.
                                                                                                                                                                                                                                                                                                                                  	CreationDate *time.Time
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// A custom domain name that you provide to Amazon Cognito. This parameter applies
                                                                                                                                                                                                                                                                                                                                  	// only if you use a custom domain to host the sign-up and sign-in pages for your
                                                                                                                                                                                                                                                                                                                                  	// application. For example: auth.example.com. For more information about adding a
                                                                                                                                                                                                                                                                                                                                  	// custom domain to your user pool, see Using Your Own Domain for the Hosted UI
                                                                                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-add-custom-domain.html).
                                                                                                                                                                                                                                                                                                                                  	CustomDomain *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The device configuration.
                                                                                                                                                                                                                                                                                                                                  	DeviceConfiguration *DeviceConfigurationType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Holds the domain prefix if the user pool has a domain associated with it.
                                                                                                                                                                                                                                                                                                                                  	Domain *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The email configuration.
                                                                                                                                                                                                                                                                                                                                  	EmailConfiguration *EmailConfigurationType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The reason why the email configuration cannot send the messages to your users.
                                                                                                                                                                                                                                                                                                                                  	EmailConfigurationFailure *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The contents of the email verification message.
                                                                                                                                                                                                                                                                                                                                  	EmailVerificationMessage *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The subject of the email verification message.
                                                                                                                                                                                                                                                                                                                                  	EmailVerificationSubject *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// A number estimating the size of the user pool.
                                                                                                                                                                                                                                                                                                                                  	EstimatedNumberOfUsers int32
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The ID of the user pool.
                                                                                                                                                                                                                                                                                                                                  	Id *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The AWS Lambda triggers associated with the user pool.
                                                                                                                                                                                                                                                                                                                                  	LambdaConfig *LambdaConfigType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The date the user pool was last modified.
                                                                                                                                                                                                                                                                                                                                  	LastModifiedDate *time.Time
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Can be one of the following values:
                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                  	// * OFF - MFA tokens are not required and
                                                                                                                                                                                                                                                                                                                                  	// cannot be specified during user registration.
                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                  	// * ON - MFA tokens are required
                                                                                                                                                                                                                                                                                                                                  	// for all user registrations. You can only specify required when you are initially
                                                                                                                                                                                                                                                                                                                                  	// creating a user pool.
                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                  	// * OPTIONAL - Users have the option when registering to
                                                                                                                                                                                                                                                                                                                                  	// create an MFA token.
                                                                                                                                                                                                                                                                                                                                  	MfaConfiguration UserPoolMfaType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The name of the user pool.
                                                                                                                                                                                                                                                                                                                                  	Name *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The policies associated with the user pool.
                                                                                                                                                                                                                                                                                                                                  	Policies *UserPoolPolicyType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// A container with the schema attributes of a user pool.
                                                                                                                                                                                                                                                                                                                                  	SchemaAttributes []SchemaAttributeType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The contents of the SMS authentication message.
                                                                                                                                                                                                                                                                                                                                  	SmsAuthenticationMessage *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The SMS configuration.
                                                                                                                                                                                                                                                                                                                                  	SmsConfiguration *SmsConfigurationType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The reason why the SMS configuration cannot send the messages to your users.
                                                                                                                                                                                                                                                                                                                                  	SmsConfigurationFailure *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The contents of the SMS verification message.
                                                                                                                                                                                                                                                                                                                                  	SmsVerificationMessage *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The status of a user pool.
                                                                                                                                                                                                                                                                                                                                  	Status StatusType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The user pool add-ons.
                                                                                                                                                                                                                                                                                                                                  	UserPoolAddOns *UserPoolAddOnsType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The tags that are assigned to the user pool. A tag is a label that you can apply
                                                                                                                                                                                                                                                                                                                                  	// to user pools to categorize and manage them in different ways, such as by
                                                                                                                                                                                                                                                                                                                                  	// purpose, owner, environment, or other criteria.
                                                                                                                                                                                                                                                                                                                                  	UserPoolTags map[string]string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// Specifies whether email addresses or phone numbers can be specified as usernames
                                                                                                                                                                                                                                                                                                                                  	// when a user signs up.
                                                                                                                                                                                                                                                                                                                                  	UsernameAttributes []UsernameAttributeType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// You can choose to enable case sensitivity on the username input for the selected
                                                                                                                                                                                                                                                                                                                                  	// sign-in option. For example, when this is set to False, users will be able to
                                                                                                                                                                                                                                                                                                                                  	// sign in using either "username" or "Username". This configuration is immutable
                                                                                                                                                                                                                                                                                                                                  	// once it has been set. For more information, see UsernameConfigurationType
                                                                                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_UsernameConfigurationType.html).
                                                                                                                                                                                                                                                                                                                                  	UsernameConfiguration *UsernameConfigurationType
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The template for verification messages.
                                                                                                                                                                                                                                                                                                                                  	VerificationMessageTemplate *VerificationMessageTemplateType
                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                    A container for information about the user pool.

                                                                                                                                                                                                                                                                                                                                    type UserStatusType

                                                                                                                                                                                                                                                                                                                                    type UserStatusType string
                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                    	UserStatusTypeUnconfirmed         UserStatusType = "UNCONFIRMED"
                                                                                                                                                                                                                                                                                                                                    	UserStatusTypeConfirmed           UserStatusType = "CONFIRMED"
                                                                                                                                                                                                                                                                                                                                    	UserStatusTypeArchived            UserStatusType = "ARCHIVED"
                                                                                                                                                                                                                                                                                                                                    	UserStatusTypeCompromised         UserStatusType = "COMPROMISED"
                                                                                                                                                                                                                                                                                                                                    	UserStatusTypeUnknown             UserStatusType = "UNKNOWN"
                                                                                                                                                                                                                                                                                                                                    	UserStatusTypeResetRequired       UserStatusType = "RESET_REQUIRED"
                                                                                                                                                                                                                                                                                                                                    	UserStatusTypeForceChangePassword UserStatusType = "FORCE_CHANGE_PASSWORD"
                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                      Enum values for UserStatusType

                                                                                                                                                                                                                                                                                                                                      func (UserStatusType) Values

                                                                                                                                                                                                                                                                                                                                      func (UserStatusType) Values() []UserStatusType

                                                                                                                                                                                                                                                                                                                                        Values returns all known values for UserStatusType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                        type UserType

                                                                                                                                                                                                                                                                                                                                        type UserType struct {
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// A container with information about the user type attributes.
                                                                                                                                                                                                                                                                                                                                        	Attributes []AttributeType
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// Specifies whether the user is enabled.
                                                                                                                                                                                                                                                                                                                                        	Enabled bool
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The MFA options for the user.
                                                                                                                                                                                                                                                                                                                                        	MFAOptions []MFAOptionType
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The creation date of the user.
                                                                                                                                                                                                                                                                                                                                        	UserCreateDate *time.Time
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The last modified date of the user.
                                                                                                                                                                                                                                                                                                                                        	UserLastModifiedDate *time.Time
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The user status. Can be one of the following:
                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                        	// * UNCONFIRMED - User has been
                                                                                                                                                                                                                                                                                                                                        	// created but not confirmed.
                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                        	// * CONFIRMED - User has been confirmed.
                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                        	// * ARCHIVED -
                                                                                                                                                                                                                                                                                                                                        	// User is no longer active.
                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                        	// * COMPROMISED - User is disabled due to a potential
                                                                                                                                                                                                                                                                                                                                        	// security threat.
                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                        	// * UNKNOWN - User status is not known.
                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                        	// * RESET_REQUIRED - User
                                                                                                                                                                                                                                                                                                                                        	// is confirmed, but the user must request a code and reset his or her password
                                                                                                                                                                                                                                                                                                                                        	// before he or she can sign in.
                                                                                                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                                                                                                        	// * FORCE_CHANGE_PASSWORD - The user is confirmed
                                                                                                                                                                                                                                                                                                                                        	// and the user can sign in using a temporary password, but on first sign-in, the
                                                                                                                                                                                                                                                                                                                                        	// user must change his or her password to a new value before doing anything else.
                                                                                                                                                                                                                                                                                                                                        	UserStatus UserStatusType
                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                        	// The user name of the user you wish to describe.
                                                                                                                                                                                                                                                                                                                                        	Username *string
                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                          The user type.

                                                                                                                                                                                                                                                                                                                                          type UsernameAttributeType

                                                                                                                                                                                                                                                                                                                                          type UsernameAttributeType string
                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                          	UsernameAttributeTypePhoneNumber UsernameAttributeType = "phone_number"
                                                                                                                                                                                                                                                                                                                                          	UsernameAttributeTypeEmail       UsernameAttributeType = "email"
                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                            Enum values for UsernameAttributeType

                                                                                                                                                                                                                                                                                                                                            func (UsernameAttributeType) Values

                                                                                                                                                                                                                                                                                                                                              Values returns all known values for UsernameAttributeType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                              type UsernameConfigurationType

                                                                                                                                                                                                                                                                                                                                              type UsernameConfigurationType struct {
                                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                                              	// Specifies whether username case sensitivity will be applied for all users in the
                                                                                                                                                                                                                                                                                                                                              	// user pool through Cognito APIs. Valid values include:
                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                              	// * True : Enables case
                                                                                                                                                                                                                                                                                                                                              	// sensitivity for all username input. When this option is set to True, users must
                                                                                                                                                                                                                                                                                                                                              	// sign in using the exact capitalization of their given username. For example,
                                                                                                                                                                                                                                                                                                                                              	// “UserName”. This is the default value.
                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                              	// * False : Enables case insensitivity for
                                                                                                                                                                                                                                                                                                                                              	// all username input. For example, when this option is set to False, users will be
                                                                                                                                                                                                                                                                                                                                              	// able to sign in using either "username" or "Username". This option also enables
                                                                                                                                                                                                                                                                                                                                              	// both preferred_username and email alias to be case insensitive, in addition to
                                                                                                                                                                                                                                                                                                                                              	// the username attribute.
                                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                                                                                              	CaseSensitive *bool
                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                The username configuration type.

                                                                                                                                                                                                                                                                                                                                                type UsernameExistsException

                                                                                                                                                                                                                                                                                                                                                type UsernameExistsException struct {
                                                                                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                  This exception is thrown when Amazon Cognito encounters a user name that already exists in the user pool.

                                                                                                                                                                                                                                                                                                                                                  func (*UsernameExistsException) Error

                                                                                                                                                                                                                                                                                                                                                  func (e *UsernameExistsException) Error() string

                                                                                                                                                                                                                                                                                                                                                  func (*UsernameExistsException) ErrorCode

                                                                                                                                                                                                                                                                                                                                                  func (e *UsernameExistsException) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                  func (*UsernameExistsException) ErrorFault

                                                                                                                                                                                                                                                                                                                                                  func (e *UsernameExistsException) ErrorFault() smithy.ErrorFault

                                                                                                                                                                                                                                                                                                                                                  func (*UsernameExistsException) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                  func (e *UsernameExistsException) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                  type VerificationMessageTemplateType

                                                                                                                                                                                                                                                                                                                                                  type VerificationMessageTemplateType struct {
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The default email option.
                                                                                                                                                                                                                                                                                                                                                  	DefaultEmailOption DefaultEmailOptionType
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The email message template. EmailMessage is allowed only if  EmailSendingAccount
                                                                                                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_EmailConfigurationType.html#CognitoUserPools-Type-EmailConfigurationType-EmailSendingAccount)
                                                                                                                                                                                                                                                                                                                                                  	// is DEVELOPER.
                                                                                                                                                                                                                                                                                                                                                  	EmailMessage *string
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The email message template for sending a confirmation link to the user.
                                                                                                                                                                                                                                                                                                                                                  	// EmailMessageByLink is allowed only if  EmailSendingAccount
                                                                                                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_EmailConfigurationType.html#CognitoUserPools-Type-EmailConfigurationType-EmailSendingAccount)
                                                                                                                                                                                                                                                                                                                                                  	// is DEVELOPER.
                                                                                                                                                                                                                                                                                                                                                  	EmailMessageByLink *string
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The subject line for the email message template. EmailSubject is allowed only if
                                                                                                                                                                                                                                                                                                                                                  	// EmailSendingAccount
                                                                                                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_EmailConfigurationType.html#CognitoUserPools-Type-EmailConfigurationType-EmailSendingAccount)
                                                                                                                                                                                                                                                                                                                                                  	// is DEVELOPER.
                                                                                                                                                                                                                                                                                                                                                  	EmailSubject *string
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The subject line for the email message template for sending a confirmation link
                                                                                                                                                                                                                                                                                                                                                  	// to the user. EmailSubjectByLink is allowed only  EmailSendingAccount
                                                                                                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_EmailConfigurationType.html#CognitoUserPools-Type-EmailConfigurationType-EmailSendingAccount)
                                                                                                                                                                                                                                                                                                                                                  	// is DEVELOPER.
                                                                                                                                                                                                                                                                                                                                                  	EmailSubjectByLink *string
                                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                                  	// The SMS message template.
                                                                                                                                                                                                                                                                                                                                                  	SmsMessage *string
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                    The template for verification messages.

                                                                                                                                                                                                                                                                                                                                                    type VerifiedAttributeType

                                                                                                                                                                                                                                                                                                                                                    type VerifiedAttributeType string
                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                    	VerifiedAttributeTypePhoneNumber VerifiedAttributeType = "phone_number"
                                                                                                                                                                                                                                                                                                                                                    	VerifiedAttributeTypeEmail       VerifiedAttributeType = "email"
                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                      Enum values for VerifiedAttributeType

                                                                                                                                                                                                                                                                                                                                                      func (VerifiedAttributeType) Values

                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for VerifiedAttributeType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                                                                        type VerifySoftwareTokenResponseType

                                                                                                                                                                                                                                                                                                                                                        type VerifySoftwareTokenResponseType string
                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                        	VerifySoftwareTokenResponseTypeSuccess VerifySoftwareTokenResponseType = "SUCCESS"
                                                                                                                                                                                                                                                                                                                                                        	VerifySoftwareTokenResponseTypeError   VerifySoftwareTokenResponseType = "ERROR"
                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                          Enum values for VerifySoftwareTokenResponseType

                                                                                                                                                                                                                                                                                                                                                          func (VerifySoftwareTokenResponseType) Values

                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for VerifySoftwareTokenResponseType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.