const ServiceAPIVersion = "2016-04-18"

const ServiceID = "Cognito Identity Provider"

type AddCustomAttributesInput struct {

	// An array of custom attributes, such as Mutable and Name.
	//
	// This member is required.
	CustomAttributes []types.SchemaAttributeType

	// The user pool ID for the user pool where you want to add custom attributes.
	//
	// This member is required.
	UserPoolId *string
}

type AddCustomAttributesOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminAddUserToGroupInput struct {

	// The group name.
	//
	// This member is required.
	GroupName *string

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string

	// The username for the user.
	//
	// This member is required.
	Username *string
}

type AdminAddUserToGroupOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminConfirmSignUpInput struct {

	// The user pool ID for which you want to confirm user registration.
	//
	// This member is required.
	UserPoolId *string

	// The user name for which you want to confirm user registration.
	//
	// This member is required.
	Username *string

	// A map of custom key-value pairs that you can provide as input for any custom
	// workflows that this action triggers. If your user pool configuration includes
	// triggers, the AdminConfirmSignUp API action invokes the AWS Lambda function that
	// is specified for the post confirmation trigger. When Amazon Cognito invokes this
	// function, it passes a JSON payload, which the function receives as input. In
	// this payload, the clientMetadata attribute provides the data that you assigned
	// to the ClientMetadata parameter in your AdminConfirmSignUp request. In your
	// function code in AWS Lambda, you can process the ClientMetadata value to enhance
	// your workflow for your specific needs. For more information, see Customizing
	// User Pool Workflows with Lambda Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]string
}

type AdminConfirmSignUpOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminCreateUserInput struct {

	// The user pool ID for the user pool where the user will be created.
	//
	// This member is required.
	UserPoolId *string

	// The username for the user. Must be unique within the user pool. Must be a UTF-8
	// string between 1 and 128 characters. After the user is created, the username
	// cannot be changed.
	//
	// This member is required.
	Username *string

	// A map of custom key-value pairs that you can provide as input for any custom
	// workflows that this action triggers. You create custom workflows by assigning
	// AWS Lambda functions to user pool triggers. When you use the AdminCreateUser API
	// action, Amazon Cognito invokes the function that is assigned to the pre sign-up
	// trigger. When Amazon Cognito invokes this function, it passes a JSON payload,
	// which the function receives as input. This payload contains a clientMetadata
	// attribute, which provides the data that you assigned to the ClientMetadata
	// parameter in your AdminCreateUser request. In your function code in AWS Lambda,
	// you can process the clientMetadata value to enhance your workflow for your
	// specific needs. For more information, see Customizing User Pool Workflows with
	// Lambda Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]string

	// Specify "EMAIL" if email will be used to send the welcome message. Specify "SMS"
	// if the phone number will be used. The default value is "SMS". More than one
	// value can be specified.
	DesiredDeliveryMediums []types.DeliveryMediumType

	// This parameter is only used if the phone_number_verified or email_verified
	// attribute is set to True. Otherwise, it is ignored. If this parameter is set to
	// True and the phone number or email address specified in the UserAttributes
	// parameter already exists as an alias with a different user, the API call will
	// migrate the alias from the previous user to the newly created user. The previous
	// user will no longer be able to log in using that alias. If this parameter is set
	// to False, the API throws an AliasExistsException error if the alias already
	// exists. The default value is False.
	ForceAliasCreation bool

	// Set to "RESEND" to resend the invitation message to a user that already exists
	// and reset the expiration limit on the user's account. Set to "SUPPRESS" to
	// suppress sending the message. Only one value can be specified.
	MessageAction types.MessageActionType

	// The user's temporary password. This password must conform to the password policy
	// that you specified when you created the user pool. The temporary password is
	// valid only once. To complete the Admin Create User flow, the user must enter the
	// temporary password in the sign-in page along with a new password to be used in
	// all future sign-ins. This parameter is not required. If you do not specify a
	// value, Amazon Cognito generates one for you. The temporary password can only be
	// used until the user account expiration limit that you specified when you created
	// the user pool. To reset the account after that time limit, you must call
	// AdminCreateUser again, specifying "RESEND" for the MessageAction parameter.
	TemporaryPassword *string

	// An array of name-value pairs that contain user attributes and attribute values
	// to be set for the user to be created. You can create a user without specifying
	// any attributes other than Username. However, any attributes that you specify as
	// required (when creating a user pool or in the Attributes tab of the console)
	// must be supplied either by you (in your call to AdminCreateUser) or by the user
	// (when he or she signs up in response to your welcome message). For custom
	// attributes, you must prepend the custom: prefix to the attribute name. To send a
	// message inviting the user to sign up, you must specify the user's email address
	// or phone number. This can be done in your call to AdminCreateUser or in the
	// Users tab of the Amazon Cognito console for managing your user pools. In your
	// call to AdminCreateUser, you can set the email_verified attribute to True, and
	// you can set the phone_number_verified attribute to True. (You can also do this
	// by calling AdminUpdateUserAttributes
	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminUpdateUserAttributes.html).)
	//
	// *
	// email: The email address of the user to whom the message that contains the code
	// and username will be sent. Required if the email_verified attribute is set to
	// True, or if "EMAIL" is specified in the DesiredDeliveryMediums parameter.
	//
	// *
	// phone_number: The phone number of the user to whom the message that contains the
	// code and username will be sent. Required if the phone_number_verified attribute
	// is set to True, or if "SMS" is specified in the DesiredDeliveryMediums
	// parameter.
	UserAttributes []types.AttributeType

	// The user's validation data. This is an array of name-value pairs that contain
	// user attributes and attribute values that you can use for custom validation,
	// such as restricting the types of user accounts that can be registered. For
	// example, you might choose to allow or disallow user sign-up based on the user's
	// domain. To configure custom validation, you must create a Pre Sign-up Lambda
	// trigger for the user pool as described in the Amazon Cognito Developer Guide.
	// The Lambda trigger receives the validation data and uses it in the validation
	// process. The user's validation data is not persisted.
	ValidationData []types.AttributeType
}

type AdminCreateUserOutput struct {

	// The newly created user.
	User *types.UserType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminDeleteUserAttributesInput struct {

	// An array of strings representing the user attribute names you wish to delete.
	// For custom attributes, you must prepend the custom: prefix to the attribute
	// name.
	//
	// This member is required.
	UserAttributeNames []string

	// The user pool ID for the user pool where you want to delete user attributes.
	//
	// This member is required.
	UserPoolId *string

	// The user name of the user from which you would like to delete attributes.
	//
	// This member is required.
	Username *string
}

type AdminDeleteUserAttributesOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminDeleteUserInput struct {

	// The user pool ID for the user pool where you want to delete the user.
	//
	// This member is required.
	UserPoolId *string

	// The user name of the user you wish to delete.
	//
	// This member is required.
	Username *string
}

type AdminDeleteUserOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminDisableProviderForUserInput struct {

	// The user to be disabled.
	//
	// This member is required.
	User *types.ProviderUserIdentifierType

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string
}

type AdminDisableProviderForUserOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminDisableUserInput struct {

	// The user pool ID for the user pool where you want to disable the user.
	//
	// This member is required.
	UserPoolId *string

	// The user name of the user you wish to disable.
	//
	// This member is required.
	Username *string
}

type AdminDisableUserOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminEnableUserInput struct {

	// The user pool ID for the user pool where you want to enable the user.
	//
	// This member is required.
	UserPoolId *string

	// The user name of the user you wish to enable.
	//
	// This member is required.
	Username *string
}

type AdminEnableUserOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminForgetDeviceInput struct {

	// The device key.
	//
	// This member is required.
	DeviceKey *string

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The user name.
	//
	// This member is required.
	Username *string
}

type AdminForgetDeviceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminGetDeviceInput struct {

	// The device key.
	//
	// This member is required.
	DeviceKey *string

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The user name.
	//
	// This member is required.
	Username *string
}

type AdminGetDeviceOutput struct {

	// The device.
	//
	// This member is required.
	Device *types.DeviceType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminGetUserInput struct {

	// The user pool ID for the user pool where you want to get information about the
	// user.
	//
	// This member is required.
	UserPoolId *string

	// The user name of the user you wish to retrieve.
	//
	// This member is required.
	Username *string
}

type AdminGetUserOutput struct {

	// The user name of the user about whom you are receiving information.
	//
	// This member is required.
	Username *string

	// Indicates that the status is enabled.
	Enabled bool

	// This response parameter is no longer supported. It provides information only
	// about SMS MFA configurations. It doesn't provide information about TOTP software
	// token MFA configurations. To look up information about either type of MFA
	// configuration, use UserMFASettingList instead.
	MFAOptions []types.MFAOptionType

	// The user's preferred MFA setting.
	PreferredMfaSetting *string

	// An array of name-value pairs representing user attributes.
	UserAttributes []types.AttributeType

	// The date the user was created.
	UserCreateDate *time.Time

	// The date the user was last modified.
	UserLastModifiedDate *time.Time

	// The MFA options that are enabled for the user. The possible values in this list
	// are SMS_MFA and SOFTWARE_TOKEN_MFA.
	UserMFASettingList []string

	// 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 types.UserStatusType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminInitiateAuthInput struct {

	// The authentication flow for this call to execute. The API action will depend on
	// this value. For example:
	//
	// * REFRESH_TOKEN_AUTH will take in a valid refresh
	// token and return new tokens.
	//
	// * USER_SRP_AUTH will take in USERNAME and SRP_A
	// and return the SRP variables to be used for next challenge execution.
	//
	// *
	// USER_PASSWORD_AUTH will take in USERNAME and PASSWORD and return the next
	// challenge or tokens.
	//
	// Valid values include:
	//
	// * USER_SRP_AUTH: Authentication
	// flow for the Secure Remote Password (SRP) protocol.
	//
	// *
	// REFRESH_TOKEN_AUTH/REFRESH_TOKEN: Authentication flow for refreshing the access
	// token and ID token by supplying a valid refresh token.
	//
	// * CUSTOM_AUTH: Custom
	// authentication flow.
	//
	// * ADMIN_NO_SRP_AUTH: Non-SRP authentication flow; you can
	// pass in the USERNAME and PASSWORD directly if the flow is enabled for calling
	// the app client.
	//
	// * USER_PASSWORD_AUTH: Non-SRP authentication flow; USERNAME and
	// PASSWORD are passed directly. If a user migration Lambda trigger is set, this
	// flow will invoke the user migration Lambda if the USERNAME is not found in the
	// user pool.
	//
	// * ADMIN_USER_PASSWORD_AUTH: Admin-based user password
	// authentication. This replaces the ADMIN_NO_SRP_AUTH authentication flow. In this
	// flow, Cognito receives the password in the request instead of using the SRP
	// process to verify passwords.
	//
	// This member is required.
	AuthFlow types.AuthFlowType

	// The app client ID.
	//
	// This member is required.
	ClientId *string

	// The ID of the Amazon Cognito user pool.
	//
	// This member is required.
	UserPoolId *string

	// The analytics metadata for collecting Amazon Pinpoint metrics for
	// AdminInitiateAuth calls.
	AnalyticsMetadata *types.AnalyticsMetadataType

	// The authentication parameters. These are inputs corresponding to the AuthFlow
	// that you are invoking. The required values depend on the value of AuthFlow:
	//
	// *
	// For USER_SRP_AUTH: USERNAME (required), SRP_A (required), SECRET_HASH (required
	// if the app client is configured with a client secret), DEVICE_KEY.
	//
	// * For
	// REFRESH_TOKEN_AUTH/REFRESH_TOKEN: REFRESH_TOKEN (required), SECRET_HASH
	// (required if the app client is configured with a client secret), DEVICE_KEY.
	//
	// *
	// For ADMIN_NO_SRP_AUTH: USERNAME (required), SECRET_HASH (if app client is
	// configured with client secret), PASSWORD (required), DEVICE_KEY.
	//
	// * For
	// CUSTOM_AUTH: USERNAME (required), SECRET_HASH (if app client is configured with
	// client secret), DEVICE_KEY. To start the authentication flow with password
	// verification, include ChallengeName: SRP_A and SRP_A: (The SRP_A Value).
	AuthParameters map[string]string

	// A map of custom key-value pairs that you can provide as input for certain custom
	// workflows that this action triggers. You create custom workflows by assigning
	// AWS Lambda functions to user pool triggers. When you use the AdminInitiateAuth
	// API action, Amazon Cognito invokes the AWS Lambda functions that are specified
	// for various triggers. The ClientMetadata value is passed as input to the
	// functions for only the following triggers:
	//
	// * Pre signup
	//
	// * Pre
	// authentication
	//
	// * User migration
	//
	// When Amazon Cognito invokes the functions for
	// these triggers, it passes a JSON payload, which the function receives as input.
	// This payload contains a validationData attribute, which provides the data that
	// you assigned to the ClientMetadata parameter in your AdminInitiateAuth request.
	// In your function code in AWS Lambda, you can process the validationData value to
	// enhance your workflow for your specific needs. When you use the
	// AdminInitiateAuth API action, Amazon Cognito also invokes the functions for the
	// following triggers, but it does not provide the ClientMetadata value as
	// input:
	//
	// * Post authentication
	//
	// * Custom message
	//
	// * Pre token generation
	//
	// *
	// Create auth challenge
	//
	// * Define auth challenge
	//
	// * Verify auth challenge
	//
	// For
	// more information, see Customizing User Pool Workflows with Lambda Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]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.
	ContextData *types.ContextDataType
}

type AdminInitiateAuthOutput struct {

	// The result of the authentication response. This is only returned if the caller
	// does not need to pass another challenge. If the caller does need to pass another
	// challenge before it gets tokens, ChallengeName, ChallengeParameters, and Session
	// are returned.
	AuthenticationResult *types.AuthenticationResultType

	// The name of the challenge which you are responding to with this call. This is
	// returned to you in the AdminInitiateAuth response if you need to pass another
	// challenge.
	//
	// * MFA_SETUP: If MFA is required, users who do not have at least one
	// of the MFA methods set up are presented with an MFA_SETUP challenge. The user
	// must set up at least one MFA type to continue to authenticate.
	//
	// *
	// SELECT_MFA_TYPE: Selects the MFA type. Valid MFA options are SMS_MFA for text
	// SMS MFA, and SOFTWARE_TOKEN_MFA for TOTP software token MFA.
	//
	// * SMS_MFA: Next
	// challenge is to supply an SMS_MFA_CODE, delivered via SMS.
	//
	// * PASSWORD_VERIFIER:
	// Next challenge is to supply PASSWORD_CLAIM_SIGNATURE,
	// PASSWORD_CLAIM_SECRET_BLOCK, and TIMESTAMP after the client-side SRP
	// calculations.
	//
	// * CUSTOM_CHALLENGE: This is returned if your custom
	// authentication flow determines that the user should pass another challenge
	// before tokens are issued.
	//
	// * DEVICE_SRP_AUTH: If device tracking was enabled on
	// your user pool and the previous challenges were passed, this challenge is
	// returned so that Amazon Cognito can start tracking this device.
	//
	// *
	// DEVICE_PASSWORD_VERIFIER: Similar to PASSWORD_VERIFIER, but for devices only.
	//
	// *
	// ADMIN_NO_SRP_AUTH: This is returned if you need to authenticate with USERNAME
	// and PASSWORD directly. An app client must be enabled to use this flow.
	//
	// *
	// NEW_PASSWORD_REQUIRED: For users which are required to change their passwords
	// after successful first login. This challenge should be passed with NEW_PASSWORD
	// and any other required attributes.
	ChallengeName types.ChallengeNameType

	// The challenge parameters. These are returned to you in the AdminInitiateAuth
	// response if you need to pass another challenge. The responses in this parameter
	// should be used to compute inputs to the next call (AdminRespondToAuthChallenge).
	// All challenges require USERNAME and SECRET_HASH (if applicable). The value of
	// the USER_ID_FOR_SRP attribute will be the user's actual username, not an alias
	// (such as email address or phone number), even if you specified an alias in your
	// call to AdminInitiateAuth. This is because, in the AdminRespondToAuthChallenge
	// API ChallengeResponses, the USERNAME attribute cannot be an alias.
	ChallengeParameters map[string]string

	// The session which should be passed both ways in challenge-response calls to the
	// service. If AdminInitiateAuth or AdminRespondToAuthChallenge API call determines
	// that the caller needs to go through another challenge, they return a session
	// with other challenge parameters. This session should be passed as it is to the
	// next AdminRespondToAuthChallenge API call.
	Session *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminLinkProviderForUserInput struct {

	// The existing user in the user pool to be linked to the external identity
	// provider user account. Can be a native (Username + Password) Cognito User Pools
	// user or a federated user (for example, a SAML or Facebook user). If the user
	// doesn't exist, an exception is thrown. This is the user that is returned when
	// the new user (with the linked identity provider attribute) signs in. For a
	// native username + password user, the ProviderAttributeValue for the
	// DestinationUser should be the username in the user pool. For a federated user,
	// it should be the provider-specific user_id. The ProviderAttributeName of the
	// DestinationUser is ignored. The ProviderName should be set to Cognito for users
	// in Cognito user pools.
	//
	// This member is required.
	DestinationUser *types.ProviderUserIdentifierType

	// An external identity provider account for a user who does not currently exist
	// yet in the user pool. This user must be a federated user (for example, a SAML or
	// Facebook user), not another native user. If the SourceUser is a federated social
	// identity provider user (Facebook, Google, or Login with Amazon), you must set
	// the ProviderAttributeName to Cognito_Subject. For social identity providers, the
	// ProviderName will be Facebook, Google, or LoginWithAmazon, and Cognito will
	// automatically parse the Facebook, Google, and Login with Amazon tokens for id,
	// sub, and user_id, respectively. The ProviderAttributeValue for the user must be
	// the same value as the id, sub, or user_id value found in the social identity
	// provider token. For SAML, the ProviderAttributeName can be any value that
	// matches a claim in the SAML assertion. If you wish to link SAML users based on
	// the subject of the SAML assertion, you should map the subject to a claim through
	// the SAML identity provider and submit that claim name as the
	// ProviderAttributeName. If you set ProviderAttributeName to Cognito_Subject,
	// Cognito will automatically parse the default unique identifier found in the
	// subject from the SAML token.
	//
	// This member is required.
	SourceUser *types.ProviderUserIdentifierType

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string
}

type AdminLinkProviderForUserOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminListDevicesInput struct {

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The user name.
	//
	// This member is required.
	Username *string

	// The limit of the devices request.
	Limit *int32

	// The pagination token.
	PaginationToken *string
}

type AdminListDevicesOutput struct {

	// The devices in the list of devices response.
	Devices []types.DeviceType

	// The pagination token.
	PaginationToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminListGroupsForUserAPIClient interface {
	AdminListGroupsForUser(context.Context, *AdminListGroupsForUserInput, ...func(*Options)) (*AdminListGroupsForUserOutput, error)
}

type AdminListGroupsForUserInput struct {

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string

	// The username for the user.
	//
	// This member is required.
	Username *string

	// The limit of the request to list groups.
	Limit *int32

	// An identifier that was returned from the previous call to this operation, which
	// can be used to return the next set of items in the list.
	NextToken *string
}

type AdminListGroupsForUserOutput struct {

	// The groups that the user belongs to.
	Groups []types.GroupType

	// An identifier that was returned from the previous call to this operation, which
	// can be used to return the next set of items in the list.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminListGroupsForUserPaginator struct {
	// contains filtered or unexported fields
}

type AdminListGroupsForUserPaginatorOptions struct {
	// The limit of the request to list groups.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type AdminListUserAuthEventsAPIClient interface {
	AdminListUserAuthEvents(context.Context, *AdminListUserAuthEventsInput, ...func(*Options)) (*AdminListUserAuthEventsOutput, error)
}

type AdminListUserAuthEventsInput struct {

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The user pool username or an alias.
	//
	// This member is required.
	Username *string

	// The maximum number of authentication events to return.
	MaxResults *int32

	// A pagination token.
	NextToken *string
}

type AdminListUserAuthEventsOutput struct {

	// The response object. It includes the EventID, EventType, CreationDate,
	// EventRisk, and EventResponse.
	AuthEvents []types.AuthEventType

	// A pagination token.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminListUserAuthEventsPaginator struct {
	// contains filtered or unexported fields
}

type AdminListUserAuthEventsPaginatorOptions struct {
	// The maximum number of authentication events to return.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type AdminRemoveUserFromGroupInput struct {

	// The group name.
	//
	// This member is required.
	GroupName *string

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string

	// The username for the user.
	//
	// This member is required.
	Username *string
}

type AdminRemoveUserFromGroupOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminResetUserPasswordInput struct {

	// The user pool ID for the user pool where you want to reset the user's password.
	//
	// This member is required.
	UserPoolId *string

	// The user name of the user whose password you wish to reset.
	//
	// This member is required.
	Username *string

	// A map of custom key-value pairs that you can provide as input for any custom
	// workflows that this action triggers. You create custom workflows by assigning
	// AWS Lambda functions to user pool triggers. When you use the
	// AdminResetUserPassword API action, Amazon Cognito invokes the function that is
	// assigned to the custom message trigger. When Amazon Cognito invokes this
	// function, it passes a JSON payload, which the function receives as input. This
	// payload contains a clientMetadata attribute, which provides the data that you
	// assigned to the ClientMetadata parameter in your AdminResetUserPassword request.
	// In your function code in AWS Lambda, you can process the clientMetadata value to
	// enhance your workflow for your specific needs. For more information, see
	// Customizing User Pool Workflows with Lambda Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]string
}

type AdminResetUserPasswordOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminRespondToAuthChallengeInput struct {

	// The challenge name. For more information, see AdminInitiateAuth
	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html).
	//
	// This member is required.
	ChallengeName types.ChallengeNameType

	// The app client ID.
	//
	// This member is required.
	ClientId *string

	// The ID of the Amazon Cognito user pool.
	//
	// This member is required.
	UserPoolId *string

	// The analytics metadata for collecting Amazon Pinpoint metrics for
	// AdminRespondToAuthChallenge calls.
	AnalyticsMetadata *types.AnalyticsMetadataType

	// The challenge responses. These are inputs corresponding to the value of
	// ChallengeName, for example:
	//
	// * SMS_MFA: SMS_MFA_CODE, USERNAME, SECRET_HASH (if
	// app client is configured with client secret).
	//
	// * PASSWORD_VERIFIER:
	// PASSWORD_CLAIM_SIGNATURE, PASSWORD_CLAIM_SECRET_BLOCK, TIMESTAMP, USERNAME,
	// SECRET_HASH (if app client is configured with client secret).
	//
	// *
	// ADMIN_NO_SRP_AUTH: PASSWORD, USERNAME, SECRET_HASH (if app client is configured
	// with client secret).
	//
	// * NEW_PASSWORD_REQUIRED: NEW_PASSWORD, any other required
	// attributes, USERNAME, SECRET_HASH (if app client is configured with client
	// secret).
	//
	// The value of the USERNAME attribute must be the user's actual
	// username, not an alias (such as email address or phone number). To make this
	// easier, the AdminInitiateAuth response includes the actual username value in the
	// USERNAMEUSER_ID_FOR_SRP attribute, even if you specified an alias in your call
	// to AdminInitiateAuth.
	ChallengeResponses map[string]string

	// A map of custom key-value pairs that you can provide as input for any custom
	// workflows that this action triggers. You create custom workflows by assigning
	// AWS Lambda functions to user pool triggers. When you use the
	// AdminRespondToAuthChallenge API action, Amazon Cognito invokes any functions
	// that are assigned to the following triggers: pre sign-up, custom message, post
	// authentication, user migration, pre token generation, define auth challenge,
	// create auth challenge, and verify auth challenge response. When Amazon Cognito
	// invokes any of these functions, it passes a JSON payload, which the function
	// receives as input. This payload contains a clientMetadata attribute, which
	// provides the data that you assigned to the ClientMetadata parameter in your
	// AdminRespondToAuthChallenge request. In your function code in AWS Lambda, you
	// can process the clientMetadata value to enhance your workflow for your specific
	// needs. For more information, see Customizing User Pool Workflows with Lambda
	// Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]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.
	ContextData *types.ContextDataType

	// The session which should be passed both ways in challenge-response calls to the
	// service. If InitiateAuth or RespondToAuthChallenge API call determines that the
	// caller needs to go through another challenge, they return a session with other
	// challenge parameters. This session should be passed as it is to the next
	// RespondToAuthChallenge API call.
	Session *string
}

type AdminRespondToAuthChallengeOutput struct {

	// The result returned by the server in response to the authentication request.
	AuthenticationResult *types.AuthenticationResultType

	// The name of the challenge. For more information, see AdminInitiateAuth
	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html).
	ChallengeName types.ChallengeNameType

	// The challenge parameters. For more information, see AdminInitiateAuth
	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminInitiateAuth.html).
	ChallengeParameters map[string]string

	// The session which should be passed both ways in challenge-response calls to the
	// service. If the caller needs to go through another challenge, they return a
	// session with other challenge parameters. This session should be passed as it is
	// to the next RespondToAuthChallenge API call.
	Session *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminSetUserMFAPreferenceInput struct {

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The user pool username or alias.
	//
	// This member is required.
	Username *string

	// The SMS text message MFA settings.
	SMSMfaSettings *types.SMSMfaSettingsType

	// The time-based one-time password software token MFA settings.
	SoftwareTokenMfaSettings *types.SoftwareTokenMfaSettingsType
}

type AdminSetUserMFAPreferenceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminSetUserPasswordInput struct {

	// The password for the user.
	//
	// This member is required.
	Password *string

	// The user pool ID for the user pool where you want to set the user's password.
	//
	// This member is required.
	UserPoolId *string

	// The user name of the user whose password you wish to set.
	//
	// This member is required.
	Username *string

	// True if the password is permanent, False if it is temporary.
	Permanent bool
}

type AdminSetUserPasswordOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminSetUserSettingsInput struct {

	// You can use this parameter only to set an SMS configuration that uses SMS for
	// delivery.
	//
	// This member is required.
	MFAOptions []types.MFAOptionType

	// The ID of the user pool that contains the user that you are setting options for.
	//
	// This member is required.
	UserPoolId *string

	// The user name of the user that you are setting options for.
	//
	// This member is required.
	Username *string
}

type AdminSetUserSettingsOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminUpdateAuthEventFeedbackInput struct {

	// The authentication event ID.
	//
	// This member is required.
	EventId *string

	// The authentication event feedback value.
	//
	// This member is required.
	FeedbackValue types.FeedbackValueType

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The user pool username.
	//
	// This member is required.
	Username *string
}

type AdminUpdateAuthEventFeedbackOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminUpdateDeviceStatusInput struct {

	// The device key.
	//
	// This member is required.
	DeviceKey *string

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The user name.
	//
	// This member is required.
	Username *string

	// The status indicating whether a device has been remembered or not.
	DeviceRememberedStatus types.DeviceRememberedStatusType
}

type AdminUpdateDeviceStatusOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminUpdateUserAttributesInput struct {

	// An array of name-value pairs representing user attributes. For custom
	// attributes, you must prepend the custom: prefix to the attribute name.
	//
	// This member is required.
	UserAttributes []types.AttributeType

	// The user pool ID for the user pool where you want to update user attributes.
	//
	// This member is required.
	UserPoolId *string

	// The user name of the user for whom you want to update user attributes.
	//
	// This member is required.
	Username *string

	// A map of custom key-value pairs that you can provide as input for any custom
	// workflows that this action triggers. You create custom workflows by assigning
	// AWS Lambda functions to user pool triggers. When you use the
	// AdminUpdateUserAttributes API action, Amazon Cognito invokes the function that
	// is assigned to the custom message trigger. When Amazon Cognito invokes this
	// function, it passes a JSON payload, which the function receives as input. This
	// payload contains a clientMetadata attribute, which provides the data that you
	// assigned to the ClientMetadata parameter in your AdminUpdateUserAttributes
	// request. In your function code in AWS Lambda, you can process the clientMetadata
	// value to enhance your workflow for your specific needs. For more information,
	// see Customizing User Pool Workflows with Lambda Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]string
}

type AdminUpdateUserAttributesOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AdminUserGlobalSignOutInput struct {

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The user name.
	//
	// This member is required.
	Username *string
}

type AdminUserGlobalSignOutOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type AssociateSoftwareTokenInput struct {

	// The access token.
	AccessToken *string

	// The session which should be passed both ways in challenge-response calls to the
	// service. This allows authentication of the user as part of the MFA setup
	// process.
	Session *string
}

type AssociateSoftwareTokenOutput struct {

	// A unique generated shared secret code that is used in the TOTP algorithm to
	// generate a one time code.
	SecretCode *string

	// The session which should be passed both ways in challenge-response calls to the
	// service. This allows authentication of the user as part of the MFA setup
	// process.
	Session *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ChangePasswordInput struct {

	// The access token.
	//
	// This member is required.
	AccessToken *string

	// The old password.
	//
	// This member is required.
	PreviousPassword *string

	// The new password.
	//
	// This member is required.
	ProposedPassword *string
}

type ChangePasswordOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Client struct {
	// contains filtered or unexported fields
}

type ConfirmDeviceInput struct {

	// The access token.
	//
	// This member is required.
	AccessToken *string

	// The device key.
	//
	// This member is required.
	DeviceKey *string

	// The device name.
	DeviceName *string

	// The configuration of the device secret verifier.
	DeviceSecretVerifierConfig *types.DeviceSecretVerifierConfigType
}

type ConfirmDeviceOutput struct {

	// Indicates whether the user confirmation is necessary to confirm the device
	// response.
	UserConfirmationNecessary bool

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ConfirmForgotPasswordInput struct {

	// The app client ID of the app associated with the user pool.
	//
	// This member is required.
	ClientId *string

	// The confirmation code sent by a user's request to retrieve a forgotten password.
	// For more information, see ForgotPassword
	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_ForgotPassword.html).
	//
	// This member is required.
	ConfirmationCode *string

	// The password sent by a user's request to retrieve a forgotten password.
	//
	// This member is required.
	Password *string

	// The user name of the user for whom you want to enter a code to retrieve a
	// forgotten password.
	//
	// This member is required.
	Username *string

	// The Amazon Pinpoint analytics metadata for collecting metrics for
	// ConfirmForgotPassword calls.
	AnalyticsMetadata *types.AnalyticsMetadataType

	// A map of custom key-value pairs that you can provide as input for any custom
	// workflows that this action triggers. You create custom workflows by assigning
	// AWS Lambda functions to user pool triggers. When you use the
	// ConfirmForgotPassword API action, Amazon Cognito invokes the function that is
	// assigned to the post confirmation trigger. When Amazon Cognito invokes this
	// function, it passes a JSON payload, which the function receives as input. This
	// payload contains a clientMetadata attribute, which provides the data that you
	// assigned to the ClientMetadata parameter in your ConfirmForgotPassword request.
	// In your function code in AWS Lambda, you can process the clientMetadata value to
	// enhance your workflow for your specific needs. For more information, see
	// Customizing User Pool Workflows with Lambda Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]string

	// A keyed-hash message authentication code (HMAC) calculated using the secret key
	// of a user pool client and username plus the client ID in the message.
	SecretHash *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.
	UserContextData *types.UserContextDataType
}

type ConfirmForgotPasswordOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ConfirmSignUpInput struct {

	// The ID of the app client associated with the user pool.
	//
	// This member is required.
	ClientId *string

	// The confirmation code sent by a user's request to confirm registration.
	//
	// This member is required.
	ConfirmationCode *string

	// The user name of the user whose registration you wish to confirm.
	//
	// This member is required.
	Username *string

	// The Amazon Pinpoint analytics metadata for collecting metrics for ConfirmSignUp
	// calls.
	AnalyticsMetadata *types.AnalyticsMetadataType

	// A map of custom key-value pairs that you can provide as input for any custom
	// workflows that this action triggers. You create custom workflows by assigning
	// AWS Lambda functions to user pool triggers. When you use the ConfirmSignUp API
	// action, Amazon Cognito invokes the function that is assigned to the post
	// confirmation trigger. When Amazon Cognito invokes this function, it passes a
	// JSON payload, which the function receives as input. This payload contains a
	// clientMetadata attribute, which provides the data that you assigned to the
	// ClientMetadata parameter in your ConfirmSignUp request. In your function code in
	// AWS Lambda, you can process the clientMetadata value to enhance your workflow
	// for your specific needs. For more information, see Customizing User Pool
	// Workflows with Lambda Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]string

	// Boolean to be specified to force user confirmation irrespective of existing
	// alias. By default set to False. If this parameter is set to True and the phone
	// number/email used for sign up confirmation already exists as an alias with a
	// different user, the API call will migrate the alias from the previous user to
	// the newly created user being confirmed. If set to False, the API will throw an
	// AliasExistsException error.
	ForceAliasCreation bool

	// A keyed-hash message authentication code (HMAC) calculated using the secret key
	// of a user pool client and username plus the client ID in the message.
	SecretHash *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.
	UserContextData *types.UserContextDataType
}

type ConfirmSignUpOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateGroupInput struct {

	// The name of the group. Must be unique.
	//
	// This member is required.
	GroupName *string

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string

	// A string containing the description of the group.
	Description *string

	// 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. Zero is the
	// highest precedence value. Groups with lower Precedence values take precedence
	// over groups with higher or null Precedence values. If a user belongs to two or
	// more groups, it is the group with the lowest precedence value whose role ARN
	// will be used in the cognito:roles and cognito:preferred_role claims in the
	// user's tokens. 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
}

type CreateGroupOutput struct {

	// The group object for the group.
	Group *types.GroupType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateIdentityProviderInput struct {

	// 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
	//
	// * For SAML providers:
	//
	// *
	// MetadataFile OR MetadataURL
	//
	// * IDPSignout optional
	//
	// This member is required.
	ProviderDetails map[string]string

	// The identity provider name.
	//
	// This member is required.
	ProviderName *string

	// The identity provider type.
	//
	// This member is required.
	ProviderType types.IdentityProviderTypeType

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// A mapping of identity provider attributes to standard and custom user pool
	// attributes.
	AttributeMapping map[string]string

	// A list of identity provider identifiers.
	IdpIdentifiers []string
}

type CreateIdentityProviderOutput struct {

	// The newly created identity provider object.
	//
	// This member is required.
	IdentityProvider *types.IdentityProviderType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateResourceServerInput struct {

	// A unique resource server identifier for the resource server. This could be an
	// HTTPS endpoint where the resource server is located. For example,
	// https://my-weather-api.example.com.
	//
	// This member is required.
	Identifier *string

	// A friendly name for the resource server.
	//
	// This member is required.
	Name *string

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string

	// A list of scopes. Each scope is map, where the keys are name and description.
	Scopes []types.ResourceServerScopeType
}

type CreateResourceServerOutput struct {

	// The newly created resource server.
	//
	// This member is required.
	ResourceServer *types.ResourceServerType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateUserImportJobInput struct {

	// The role ARN for the Amazon CloudWatch Logging role for the user import job.
	//
	// This member is required.
	CloudWatchLogsRoleArn *string

	// The job name for the user import job.
	//
	// This member is required.
	JobName *string

	// The user pool ID for the user pool that the users are being imported into.
	//
	// This member is required.
	UserPoolId *string
}

type CreateUserImportJobOutput struct {

	// The job object that represents the user import job.
	UserImportJob *types.UserImportJobType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateUserPoolClientInput struct {

	// The client name for the user pool client you would like to create.
	//
	// This member is required.
	ClientName *string

	// The user pool ID for the user pool where you want to create a user pool client.
	//
	// This member is required.
	UserPoolId *string

	// The time limit, between 5 minutes and 1 day, after which the access token is no
	// longer valid and cannot be used. This value will be overridden if you have
	// entered a value in TokenValidityUnits.
	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 []types.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 collecting metrics for this 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.
	AnalyticsConfiguration *types.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 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 []types.ExplicitAuthFlowsType

	// Boolean to specify whether you want to generate a secret for the user pool
	// client being created.
	GenerateSecret bool

	// The time limit, between 5 minutes and 1 day, after which the ID token is no
	// longer valid and cannot be used. This value will be overridden if you have
	// entered a value in TokenValidityUnits.
	IdTokenValidity *int32

	// 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 types.PreventUserExistenceErrorTypes

	// The read 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. The following are supported: COGNITO, Facebook, Google and
	// LoginWithAmazon.
	SupportedIdentityProviders []string

	// The units in which the validity times are represented in. Default for
	// RefreshToken is days, and default for ID and access tokens are hours.
	TokenValidityUnits *types.TokenValidityUnitsType

	// The user pool attributes that the app client can write to. If your app client
	// allows users to sign in through an identity provider, this array must include
	// all attributes that are mapped to identity provider attributes. Amazon Cognito
	// updates mapped attributes when users sign in to your application through an
	// identity provider. If your app client lacks write access to a mapped attribute,
	// 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).
	WriteAttributes []string
}

type CreateUserPoolClientOutput struct {

	// The user pool client that was just created.
	UserPoolClient *types.UserPoolClientType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateUserPoolDomainInput struct {

	// The domain string.
	//
	// This member is required.
	Domain *string

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The configuration for a custom domain that hosts the sign-up and sign-in
	// webpages for your application. Provide this parameter only if you want to use a
	// custom domain for your user pool. Otherwise, you can exclude this parameter and
	// use the Amazon Cognito hosted domain instead. For more information about the
	// hosted domain and custom domains, see Configuring a User Pool Domain
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-assign-domain.html).
	CustomDomainConfig *types.CustomDomainConfigType
}

type CreateUserPoolDomainOutput struct {

	// The Amazon CloudFront endpoint that you use as the target of the alias that you
	// set up with your Domain Name Service (DNS) provider.
	CloudFrontDomain *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateUserPoolInput struct {

	// A string used to name the user pool.
	//
	// This member is required.
	PoolName *string

	// 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 *types.AccountRecoverySettingType

	// The configuration for AdminCreateUser requests.
	AdminCreateUserConfig *types.AdminCreateUserConfigType

	// Attributes supported as an alias for this user pool. Possible values:
	// phone_number, email, or preferred_username.
	AliasAttributes []types.AliasAttributeType

	// The attributes to be auto-verified. Possible values: email, phone_number.
	AutoVerifiedAttributes []types.VerifiedAttributeType

	// The device configuration.
	DeviceConfiguration *types.DeviceConfigurationType

	// The email configuration.
	EmailConfiguration *types.EmailConfigurationType

	// A string representing the email verification message.
	EmailVerificationMessage *string

	// A string representing the email verification subject.
	EmailVerificationSubject *string

	// The Lambda trigger configuration information for the new user pool. In a push
	// model, event sources (such as Amazon S3 and custom applications) need permission
	// to invoke a function. So you will need to make an extra call to add permission
	// for these event sources to invoke your Lambda function. For more information on
	// using the Lambda API to add permission, see  AddPermission
	// (https://docs.aws.amazon.com/lambda/latest/dg/API_AddPermission.html). For
	// adding permission using the AWS CLI, see  add-permission
	// (https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html).
	LambdaConfig *types.LambdaConfigType

	// Specifies MFA configuration details.
	MfaConfiguration types.UserPoolMfaType

	// The policies associated with the new user pool.
	Policies *types.UserPoolPolicyType

	// An array of schema attributes for the new user pool. These attributes can be
	// standard or custom attributes.
	Schema []types.SchemaAttributeType

	// A string representing the SMS authentication message.
	SmsAuthenticationMessage *string

	// The SMS configuration.
	SmsConfiguration *types.SmsConfigurationType

	// A string representing the SMS verification message.
	SmsVerificationMessage *string

	// Used to enable advanced security risk detection. Set the key
	// AdvancedSecurityMode to the value "AUDIT".
	UserPoolAddOns *types.UserPoolAddOnsType

	// The tag keys and values to assign to the user pool. A tag is a label that you
	// can use to categorize and manage user pools 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 []types.UsernameAttributeType

	// You can choose to set 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 *types.UsernameConfigurationType

	// The template for the verification message that the user sees when the app
	// requests permission to access the user's information.
	VerificationMessageTemplate *types.VerificationMessageTemplateType
}

type CreateUserPoolOutput struct {

	// A container for the user pool details.
	UserPool *types.UserPoolType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteGroupInput struct {

	// The name of the group.
	//
	// This member is required.
	GroupName *string

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string
}

type DeleteGroupOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteIdentityProviderInput struct {

	// The identity provider name.
	//
	// This member is required.
	ProviderName *string

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string
}

type DeleteIdentityProviderOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteResourceServerInput struct {

	// The identifier for the resource server.
	//
	// This member is required.
	Identifier *string

	// The user pool ID for the user pool that hosts the resource server.
	//
	// This member is required.
	UserPoolId *string
}

type DeleteResourceServerOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteUserAttributesInput struct {

	// The access token used in the request to delete user attributes.
	//
	// This member is required.
	AccessToken *string

	// An array of strings representing the user attribute names you wish to delete.
	// For custom attributes, you must prepend the custom: prefix to the attribute
	// name.
	//
	// This member is required.
	UserAttributeNames []string
}

type DeleteUserAttributesOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteUserInput struct {

	// The access token from a request to delete a user.
	//
	// This member is required.
	AccessToken *string
}

type DeleteUserOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteUserPoolClientInput struct {

	// The app client ID of the app associated with the user pool.
	//
	// This member is required.
	ClientId *string

	// The user pool ID for the user pool where you want to delete the client.
	//
	// This member is required.
	UserPoolId *string
}

type DeleteUserPoolClientOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteUserPoolDomainInput struct {

	// The domain string.
	//
	// This member is required.
	Domain *string

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string
}

type DeleteUserPoolDomainOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteUserPoolInput struct {

	// The user pool ID for the user pool you want to delete.
	//
	// This member is required.
	UserPoolId *string
}

type DeleteUserPoolOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeIdentityProviderInput struct {

	// The identity provider name.
	//
	// This member is required.
	ProviderName *string

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string
}

type DescribeIdentityProviderOutput struct {

	// The identity provider that was deleted.
	//
	// This member is required.
	IdentityProvider *types.IdentityProviderType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeResourceServerInput struct {

	// The identifier for the resource server
	//
	// This member is required.
	Identifier *string

	// The user pool ID for the user pool that hosts the resource server.
	//
	// This member is required.
	UserPoolId *string
}

type DescribeResourceServerOutput struct {

	// The resource server.
	//
	// This member is required.
	ResourceServer *types.ResourceServerType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeRiskConfigurationInput struct {

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The app client ID.
	ClientId *string
}

type DescribeRiskConfigurationOutput struct {

	// The risk configuration.
	//
	// This member is required.
	RiskConfiguration *types.RiskConfigurationType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeUserImportJobInput struct {

	// The job ID for the user import job.
	//
	// This member is required.
	JobId *string

	// The user pool ID for the user pool that the users are being imported into.
	//
	// This member is required.
	UserPoolId *string
}

type DescribeUserImportJobOutput struct {

	// The job object that represents the user import job.
	UserImportJob *types.UserImportJobType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeUserPoolClientInput struct {

	// The app client ID of the app associated with the user pool.
	//
	// This member is required.
	ClientId *string

	// The user pool ID for the user pool you want to describe.
	//
	// This member is required.
	UserPoolId *string
}

type DescribeUserPoolClientOutput struct {

	// The user pool client from a server response to describe the user pool client.
	UserPoolClient *types.UserPoolClientType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeUserPoolDomainInput struct {

	// The domain string.
	//
	// This member is required.
	Domain *string
}

type DescribeUserPoolDomainOutput struct {

	// A domain description object containing information about the domain.
	DomainDescription *types.DomainDescriptionType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeUserPoolInput struct {

	// The user pool ID for the user pool you want to describe.
	//
	// This member is required.
	UserPoolId *string
}

type DescribeUserPoolOutput struct {

	// The container of metadata returned by the server to describe the pool.
	UserPool *types.UserPoolType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type EndpointResolver interface {
	ResolveEndpoint(region string, options EndpointResolverOptions) (aws.Endpoint, error)
}

type EndpointResolverFunc func(region string, options EndpointResolverOptions) (aws.Endpoint, error)

type EndpointResolverOptions = internalendpoints.Options

type ForgetDeviceInput struct {

	// The device key.
	//
	// This member is required.
	DeviceKey *string

	// The access token for the forgotten device request.
	AccessToken *string
}

type ForgetDeviceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ForgotPasswordInput struct {

	// The ID of the client associated with the user pool.
	//
	// This member is required.
	ClientId *string

	// The user name of the user for whom you want to enter a code to reset a forgotten
	// password.
	//
	// This member is required.
	Username *string

	// The Amazon Pinpoint analytics metadata for collecting metrics for ForgotPassword
	// calls.
	AnalyticsMetadata *types.AnalyticsMetadataType

	// A map of custom key-value pairs that you can provide as input for any custom
	// workflows that this action triggers. You create custom workflows by assigning
	// AWS Lambda functions to user pool triggers. When you use the ForgotPassword API
	// action, Amazon Cognito invokes any functions that are assigned to the following
	// triggers: pre sign-up, custom message, and user migration. When Amazon Cognito
	// invokes any of these functions, it passes a JSON payload, which the function
	// receives as input. This payload contains a clientMetadata attribute, which
	// provides the data that you assigned to the ClientMetadata parameter in your
	// ForgotPassword request. In your function code in AWS Lambda, you can process the
	// clientMetadata value to enhance your workflow for your specific needs. For more
	// information, see Customizing User Pool Workflows with Lambda Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]string

	// A keyed-hash message authentication code (HMAC) calculated using the secret key
	// of a user pool client and username plus the client ID in the message.
	SecretHash *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.
	UserContextData *types.UserContextDataType
}

type ForgotPasswordOutput struct {

	// The code delivery details returned by the server in response to the request to
	// reset a password.
	CodeDeliveryDetails *types.CodeDeliveryDetailsType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetCSVHeaderInput struct {

	// The user pool ID for the user pool that the users are to be imported into.
	//
	// This member is required.
	UserPoolId *string
}

type GetCSVHeaderOutput struct {

	// The header information for the .csv file for the user import job.
	CSVHeader []string

	// The user pool ID for the user pool that the users are to be imported into.
	UserPoolId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetDeviceInput struct {

	// The device key.
	//
	// This member is required.
	DeviceKey *string

	// The access token.
	AccessToken *string
}

type GetDeviceOutput struct {

	// The device.
	//
	// This member is required.
	Device *types.DeviceType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetGroupInput struct {

	// The name of the group.
	//
	// This member is required.
	GroupName *string

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string
}

type GetGroupOutput struct {

	// The group object for the group.
	Group *types.GroupType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetIdentityProviderByIdentifierInput struct {

	// The identity provider ID.
	//
	// This member is required.
	IdpIdentifier *string

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string
}

type GetIdentityProviderByIdentifierOutput struct {

	// The identity provider object.
	//
	// This member is required.
	IdentityProvider *types.IdentityProviderType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetSigningCertificateInput struct {

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string
}

type GetSigningCertificateOutput struct {

	// The signing certificate.
	Certificate *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetUICustomizationInput struct {

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string

	// The client ID for the client app.
	ClientId *string
}

type GetUICustomizationOutput struct {

	// The UI customization information.
	//
	// This member is required.
	UICustomization *types.UICustomizationType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetUserAttributeVerificationCodeInput struct {

	// The access token returned by the server response to get the user attribute
	// verification code.
	//
	// This member is required.
	AccessToken *string

	// The attribute name returned by the server response to get the user attribute
	// verification code.
	//
	// This member is required.
	AttributeName *string

	// A map of custom key-value pairs that you can provide as input for any custom
	// workflows that this action triggers. You create custom workflows by assigning
	// AWS Lambda functions to user pool triggers. When you use the
	// GetUserAttributeVerificationCode API action, Amazon Cognito invokes the function
	// that is assigned to the custom message trigger. When Amazon Cognito invokes this
	// function, it passes a JSON payload, which the function receives as input. This
	// payload contains a clientMetadata attribute, which provides the data that you
	// assigned to the ClientMetadata parameter in your
	// GetUserAttributeVerificationCode request. In your function code in AWS Lambda,
	// you can process the clientMetadata value to enhance your workflow for your
	// specific needs. For more information, see Customizing User Pool Workflows with
	// Lambda Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]string
}

type GetUserAttributeVerificationCodeOutput struct {

	// The code delivery details returned by the server in response to the request to
	// get the user attribute verification code.
	CodeDeliveryDetails *types.CodeDeliveryDetailsType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetUserInput struct {

	// The access token returned by the server response to get information about the
	// user.
	//
	// This member is required.
	AccessToken *string
}

type GetUserOutput struct {

	// An array of name-value pairs representing user attributes. For custom
	// attributes, you must prepend the custom: prefix to the attribute name.
	//
	// This member is required.
	UserAttributes []types.AttributeType

	// The user name of the user you wish to retrieve from the get user request.
	//
	// This member is required.
	Username *string

	// This response parameter is no longer supported. It provides information only
	// about SMS MFA configurations. It doesn't provide information about TOTP software
	// token MFA configurations. To look up information about either type of MFA
	// configuration, use UserMFASettingList instead.
	MFAOptions []types.MFAOptionType

	// The user's preferred MFA setting.
	PreferredMfaSetting *string

	// The MFA options that are enabled for the user. The possible values in this list
	// are SMS_MFA and SOFTWARE_TOKEN_MFA.
	UserMFASettingList []string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetUserPoolMfaConfigInput struct {

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string
}

type GetUserPoolMfaConfigOutput struct {

	// The multi-factor (MFA) configuration. Valid values include:
	//
	// * OFF MFA will not
	// be used for any users.
	//
	// * ON MFA is required for all users to sign in.
	//
	// *
	// OPTIONAL MFA will be required only for individual users who have an MFA factor
	// enabled.
	MfaConfiguration types.UserPoolMfaType

	// The SMS text message multi-factor (MFA) configuration.
	SmsMfaConfiguration *types.SmsMfaConfigType

	// The software token multi-factor (MFA) configuration.
	SoftwareTokenMfaConfiguration *types.SoftwareTokenMfaConfigType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GlobalSignOutInput struct {

	// The access token.
	//
	// This member is required.
	AccessToken *string
}

type GlobalSignOutOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type HTTPClient interface {
	Do(*http.Request) (*http.Response, error)
}

type HTTPSignerV4 interface {
	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time) error
}

type InitiateAuthInput struct {

	// The authentication flow for this call to execute. The API action will depend on
	// this value. For example:
	//
	// * REFRESH_TOKEN_AUTH will take in a valid refresh
	// token and return new tokens.
	//
	// * USER_SRP_AUTH will take in USERNAME and SRP_A
	// and return the SRP variables to be used for next challenge execution.
	//
	// *
	// USER_PASSWORD_AUTH will take in USERNAME and PASSWORD and return the next
	// challenge or tokens.
	//
	// Valid values include:
	//
	// * USER_SRP_AUTH: Authentication
	// flow for the Secure Remote Password (SRP) protocol.
	//
	// *
	// REFRESH_TOKEN_AUTH/REFRESH_TOKEN: Authentication flow for refreshing the access
	// token and ID token by supplying a valid refresh token.
	//
	// * CUSTOM_AUTH: Custom
	// authentication flow.
	//
	// * USER_PASSWORD_AUTH: Non-SRP authentication flow;
	// USERNAME and PASSWORD are passed directly. If a user migration Lambda trigger is
	// set, this flow will invoke the user migration Lambda if the USERNAME is not
	// found in the user pool.
	//
	// * ADMIN_USER_PASSWORD_AUTH: Admin-based user password
	// authentication. This replaces the ADMIN_NO_SRP_AUTH authentication flow. In this
	// flow, Cognito receives the password in the request instead of using the SRP
	// process to verify passwords.
	//
	// ADMIN_NO_SRP_AUTH is not a valid value.
	//
	// This member is required.
	AuthFlow types.AuthFlowType

	// The app client ID.
	//
	// This member is required.
	ClientId *string

	// The Amazon Pinpoint analytics metadata for collecting metrics for InitiateAuth
	// calls.
	AnalyticsMetadata *types.AnalyticsMetadataType

	// The authentication parameters. These are inputs corresponding to the AuthFlow
	// that you are invoking. The required values depend on the value of AuthFlow:
	//
	// *
	// For USER_SRP_AUTH: USERNAME (required), SRP_A (required), SECRET_HASH (required
	// if the app client is configured with a client secret), DEVICE_KEY.
	//
	// * For
	// REFRESH_TOKEN_AUTH/REFRESH_TOKEN: REFRESH_TOKEN (required), SECRET_HASH
	// (required if the app client is configured with a client secret), DEVICE_KEY.
	//
	// *
	// For CUSTOM_AUTH: USERNAME (required), SECRET_HASH (if app client is configured
	// with client secret), DEVICE_KEY. To start the authentication flow with password
	// verification, include ChallengeName: SRP_A and SRP_A: (The SRP_A Value).
	AuthParameters map[string]string

	// A map of custom key-value pairs that you can provide as input for certain custom
	// workflows that this action triggers. You create custom workflows by assigning
	// AWS Lambda functions to user pool triggers. When you use the InitiateAuth API
	// action, Amazon Cognito invokes the AWS Lambda functions that are specified for
	// various triggers. The ClientMetadata value is passed as input to the functions
	// for only the following triggers:
	//
	// * Pre signup
	//
	// * Pre authentication
	//
	// * User
	// migration
	//
	// When Amazon Cognito invokes the functions for these triggers, it
	// passes a JSON payload, which the function receives as input. This payload
	// contains a validationData attribute, which provides the data that you assigned
	// to the ClientMetadata parameter in your InitiateAuth request. In your function
	// code in AWS Lambda, you can process the validationData value to enhance your
	// workflow for your specific needs. When you use the InitiateAuth API action,
	// Amazon Cognito also invokes the functions for the following triggers, but it
	// does not provide the ClientMetadata value as input:
	//
	// * Post authentication
	//
	// *
	// Custom message
	//
	// * Pre token generation
	//
	// * Create auth challenge
	//
	// * Define auth
	// challenge
	//
	// * Verify auth challenge
	//
	// For more information, see Customizing User
	// Pool Workflows with Lambda Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]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.
	UserContextData *types.UserContextDataType
}

type InitiateAuthOutput struct {

	// The result of the authentication response. This is only returned if the caller
	// does not need to pass another challenge. If the caller does need to pass another
	// challenge before it gets tokens, ChallengeName, ChallengeParameters, and Session
	// are returned.
	AuthenticationResult *types.AuthenticationResultType

	// The name of the challenge which you are responding to with this call. This is
	// returned to you in the AdminInitiateAuth response if you need to pass another
	// challenge. Valid values include the following. Note that all of these challenges
	// require USERNAME and SECRET_HASH (if applicable) in the parameters.
	//
	// * SMS_MFA:
	// Next challenge is to supply an SMS_MFA_CODE, delivered via SMS.
	//
	// *
	// PASSWORD_VERIFIER: Next challenge is to supply PASSWORD_CLAIM_SIGNATURE,
	// PASSWORD_CLAIM_SECRET_BLOCK, and TIMESTAMP after the client-side SRP
	// calculations.
	//
	// * CUSTOM_CHALLENGE: This is returned if your custom
	// authentication flow determines that the user should pass another challenge
	// before tokens are issued.
	//
	// * DEVICE_SRP_AUTH: If device tracking was enabled on
	// your user pool and the previous challenges were passed, this challenge is
	// returned so that Amazon Cognito can start tracking this device.
	//
	// *
	// DEVICE_PASSWORD_VERIFIER: Similar to PASSWORD_VERIFIER, but for devices only.
	//
	// *
	// NEW_PASSWORD_REQUIRED: For users which are required to change their passwords
	// after successful first login. This challenge should be passed with NEW_PASSWORD
	// and any other required attributes.
	ChallengeName types.ChallengeNameType

	// The challenge parameters. These are returned to you in the InitiateAuth response
	// if you need to pass another challenge. The responses in this parameter should be
	// used to compute inputs to the next call (RespondToAuthChallenge). All challenges
	// require USERNAME and SECRET_HASH (if applicable).
	ChallengeParameters map[string]string

	// The session which should be passed both ways in challenge-response calls to the
	// service. If the caller needs to go through another challenge, they return a
	// session with other challenge parameters. This session should be passed as it is
	// to the next RespondToAuthChallenge API call.
	Session *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListDevicesInput struct {

	// The access tokens for the request to list devices.
	//
	// This member is required.
	AccessToken *string

	// The limit of the device request.
	Limit *int32

	// The pagination token for the list request.
	PaginationToken *string
}

type ListDevicesOutput struct {

	// The devices returned in the list devices response.
	Devices []types.DeviceType

	// The pagination token for the list device response.
	PaginationToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListGroupsAPIClient interface {
	ListGroups(context.Context, *ListGroupsInput, ...func(*Options)) (*ListGroupsOutput, error)
}

type ListGroupsInput struct {

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string

	// The limit of the request to list groups.
	Limit *int32

	// An identifier that was returned from the previous call to this operation, which
	// can be used to return the next set of items in the list.
	NextToken *string
}

type ListGroupsOutput struct {

	// The group objects for the groups.
	Groups []types.GroupType

	// An identifier that was returned from the previous call to this operation, which
	// can be used to return the next set of items in the list.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListGroupsPaginator struct {
	// contains filtered or unexported fields
}

type ListGroupsPaginatorOptions struct {
	// The limit of the request to list groups.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListIdentityProvidersAPIClient interface {
	ListIdentityProviders(context.Context, *ListIdentityProvidersInput, ...func(*Options)) (*ListIdentityProvidersOutput, error)
}

type ListIdentityProvidersInput struct {

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The maximum number of identity providers to return.
	MaxResults *int32

	// A pagination token.
	NextToken *string
}

type ListIdentityProvidersOutput struct {

	// A list of identity provider objects.
	//
	// This member is required.
	Providers []types.ProviderDescription

	// A pagination token.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListIdentityProvidersPaginator struct {
	// contains filtered or unexported fields
}

type ListIdentityProvidersPaginatorOptions struct {
	// The maximum number of identity providers to return.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListResourceServersAPIClient interface {
	ListResourceServers(context.Context, *ListResourceServersInput, ...func(*Options)) (*ListResourceServersOutput, error)
}

type ListResourceServersInput struct {

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string

	// The maximum number of resource servers to return.
	MaxResults int32

	// A pagination token.
	NextToken *string
}

type ListResourceServersOutput struct {

	// The resource servers.
	//
	// This member is required.
	ResourceServers []types.ResourceServerType

	// A pagination token.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListResourceServersPaginator struct {
	// contains filtered or unexported fields
}

type ListResourceServersPaginatorOptions struct {
	// The maximum number of resource servers to return.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListTagsForResourceInput struct {

	// The Amazon Resource Name (ARN) of the user pool that the tags are assigned to.
	//
	// This member is required.
	ResourceArn *string
}

type ListTagsForResourceOutput struct {

	// The tags that are assigned to the user pool.
	Tags map[string]string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListUserImportJobsInput struct {

	// The maximum number of import jobs you want the request to return.
	//
	// This member is required.
	MaxResults int32

	// The user pool ID for the user pool that the users are being imported into.
	//
	// This member is required.
	UserPoolId *string

	// An identifier that was returned from the previous call to ListUserImportJobs,
	// which can be used to return the next set of import jobs in the list.
	PaginationToken *string
}

type ListUserImportJobsOutput struct {

	// An identifier that can be used to return the next set of user import jobs in the
	// list.
	PaginationToken *string

	// The user import jobs.
	UserImportJobs []types.UserImportJobType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListUserPoolClientsAPIClient interface {
	ListUserPoolClients(context.Context, *ListUserPoolClientsInput, ...func(*Options)) (*ListUserPoolClientsOutput, error)
}

type ListUserPoolClientsInput struct {

	// The user pool ID for the user pool where you want to list user pool clients.
	//
	// This member is required.
	UserPoolId *string

	// The maximum number of results you want the request to return when listing the
	// user pool clients.
	MaxResults int32

	// An identifier that was returned from the previous call to this operation, which
	// can be used to return the next set of items in the list.
	NextToken *string
}

type ListUserPoolClientsOutput struct {

	// An identifier that was returned from the previous call to this operation, which
	// can be used to return the next set of items in the list.
	NextToken *string

	// The user pool clients in the response that lists user pool clients.
	UserPoolClients []types.UserPoolClientDescription

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListUserPoolClientsPaginator struct {
	// contains filtered or unexported fields
}

type ListUserPoolClientsPaginatorOptions struct {
	// The maximum number of results you want the request to return when listing the
	// user pool clients.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListUserPoolsInput struct {

	// The maximum number of results you want the request to return when listing the
	// user pools.
	//
	// This member is required.
	MaxResults int32

	// An identifier that was returned from the previous call to this operation, which
	// can be used to return the next set of items in the list.
	NextToken *string
}

type ListUserPoolsOutput struct {

	// An identifier that was returned from the previous call to this operation, which
	// can be used to return the next set of items in the list.
	NextToken *string

	// The user pools from the response to list users.
	UserPools []types.UserPoolDescriptionType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListUsersAPIClient interface {
	ListUsers(context.Context, *ListUsersInput, ...func(*Options)) (*ListUsersOutput, error)
}

type ListUsersInGroupAPIClient interface {
	ListUsersInGroup(context.Context, *ListUsersInGroupInput, ...func(*Options)) (*ListUsersInGroupOutput, error)
}

type ListUsersInGroupInput struct {

	// The name of the group.
	//
	// This member is required.
	GroupName *string

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string

	// The limit of the request to list users.
	Limit *int32

	// An identifier that was returned from the previous call to this operation, which
	// can be used to return the next set of items in the list.
	NextToken *string
}

type ListUsersInGroupOutput struct {

	// An identifier that was returned from the previous call to this operation, which
	// can be used to return the next set of items in the list.
	NextToken *string

	// The users returned in the request to list users.
	Users []types.UserType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListUsersInGroupPaginator struct {
	// contains filtered or unexported fields
}

type ListUsersInGroupPaginatorOptions struct {
	// The limit of the request to list users.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type ListUsersInput struct {

	// The user pool ID for the user pool on which the search should be performed.
	//
	// This member is required.
	UserPoolId *string

	// An array of strings, where each string is the name of a user attribute to be
	// returned for each user in the search results. If the array is null, all
	// attributes are returned.
	AttributesToGet []string

	// A filter string of the form "AttributeName Filter-Type "AttributeValue"".
	// Quotation marks within the filter string must be escaped using the backslash (\)
	// character. For example, "family_name = \"Reddy\"".
	//
	// * AttributeName: The name of
	// the attribute to search for. You can only search for one attribute at a time.
	//
	// *
	// Filter-Type: For an exact match, use =, for example, "given_name = \"Jon\"". For
	// a prefix ("starts with") match, use ^=, for example, "given_name ^= \"Jon\"".
	//
	// *
	// AttributeValue: The attribute value that must be matched for each user.
	//
	// If the
	// filter string is empty, ListUsers returns all users in the user pool. You can
	// only search for the following standard attributes:
	//
	// * username
	// (case-sensitive)
	//
	// * email
	//
	// * phone_number
	//
	// * name
	//
	// * given_name
	//
	// *
	// family_name
	//
	// * preferred_username
	//
	// * cognito:user_status (called Status in the
	// Console) (case-insensitive)
	//
	// * status (called Enabled in the Console)
	// (case-sensitive)
	//
	// * sub
	//
	// Custom attributes are not searchable. For more
	// information, see Searching for Users Using the ListUsers API
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/how-to-manage-user-accounts.html#cognito-user-pools-searching-for-users-using-listusers-api)
	// and Examples of Using the ListUsers API
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/how-to-manage-user-accounts.html#cognito-user-pools-searching-for-users-listusers-api-examples)
	// in the Amazon Cognito Developer Guide.
	Filter *string

	// Maximum number of users to be returned.
	Limit *int32

	// An identifier that was returned from the previous call to this operation, which
	// can be used to return the next set of items in the list.
	PaginationToken *string
}

type ListUsersOutput struct {

	// An identifier that was returned from the previous call to this operation, which
	// can be used to return the next set of items in the list.
	PaginationToken *string

	// The users returned in the request to list users.
	Users []types.UserType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListUsersPaginator struct {
	// contains filtered or unexported fields
}

type ListUsersPaginatorOptions struct {
	// Maximum number of users to be returned.
	Limit int32

	// Set to true if pagination should stop if the service returns a pagination token
	// that matches the most recent token provided to the service.
	StopOnDuplicateToken bool
}

type Options struct {
	// Set of options to modify how an operation is invoked. These apply to all
	// operations invoked for this client. Use functional options on operation call to
	// modify this list for per operation behavior.
	APIOptions []func(*middleware.Stack) error

	// Configures the events that will be sent to the configured logger.
	ClientLogMode aws.ClientLogMode

	// The credentials object to use when signing requests.
	Credentials aws.CredentialsProvider

	// The endpoint options to be used when attempting to resolve an endpoint.
	EndpointOptions EndpointResolverOptions

	// The service endpoint resolver.
	EndpointResolver EndpointResolver

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// The logger writer interface to write logging messages to.
	Logger logging.Logger

	// The region to send requests to. (Required)
	Region string

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer.
	Retryer retry.Retryer

	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
	// implementation if nil.
	HTTPClient HTTPClient
}

type ResendConfirmationCodeInput struct {

	// The ID of the client associated with the user pool.
	//
	// This member is required.
	ClientId *string

	// The user name of the user to whom you wish to resend a confirmation code.
	//
	// This member is required.
	Username *string

	// The Amazon Pinpoint analytics metadata for collecting metrics for
	// ResendConfirmationCode calls.
	AnalyticsMetadata *types.AnalyticsMetadataType

	// A map of custom key-value pairs that you can provide as input for any custom
	// workflows that this action triggers. You create custom workflows by assigning
	// AWS Lambda functions to user pool triggers. When you use the
	// ResendConfirmationCode API action, Amazon Cognito invokes the function that is
	// assigned to the custom message trigger. When Amazon Cognito invokes this
	// function, it passes a JSON payload, which the function receives as input. This
	// payload contains a clientMetadata attribute, which provides the data that you
	// assigned to the ClientMetadata parameter in your ResendConfirmationCode request.
	// In your function code in AWS Lambda, you can process the clientMetadata value to
	// enhance your workflow for your specific needs. For more information, see
	// Customizing User Pool Workflows with Lambda Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]string

	// A keyed-hash message authentication code (HMAC) calculated using the secret key
	// of a user pool client and username plus the client ID in the message.
	SecretHash *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.
	UserContextData *types.UserContextDataType
}

type ResendConfirmationCodeOutput struct {

	// The code delivery details returned by the server in response to the request to
	// resend the confirmation code.
	CodeDeliveryDetails *types.CodeDeliveryDetailsType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  EndpointResolverOptions
}

type RespondToAuthChallengeInput struct {

	// The challenge name. For more information, see InitiateAuth
	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html).
	// ADMIN_NO_SRP_AUTH is not a valid value.
	//
	// This member is required.
	ChallengeName types.ChallengeNameType

	// The app client ID.
	//
	// This member is required.
	ClientId *string

	// The Amazon Pinpoint analytics metadata for collecting metrics for
	// RespondToAuthChallenge calls.
	AnalyticsMetadata *types.AnalyticsMetadataType

	// The challenge responses. These are inputs corresponding to the value of
	// ChallengeName, for example: SECRET_HASH (if app client is configured with client
	// secret) applies to all inputs below (including SOFTWARE_TOKEN_MFA).
	//
	// * SMS_MFA:
	// SMS_MFA_CODE, USERNAME.
	//
	// * PASSWORD_VERIFIER: PASSWORD_CLAIM_SIGNATURE,
	// PASSWORD_CLAIM_SECRET_BLOCK, TIMESTAMP, USERNAME.
	//
	// * NEW_PASSWORD_REQUIRED:
	// NEW_PASSWORD, any other required attributes, USERNAME.
	//
	// * SOFTWARE_TOKEN_MFA:
	// USERNAME and SOFTWARE_TOKEN_MFA_CODE are required attributes.
	//
	// * DEVICE_SRP_AUTH
	// requires USERNAME, DEVICE_KEY, SRP_A (and SECRET_HASH).
	//
	// *
	// DEVICE_PASSWORD_VERIFIER requires everything that PASSWORD_VERIFIER requires
	// plus DEVICE_KEY.
	ChallengeResponses map[string]string

	// A map of custom key-value pairs that you can provide as input for any custom
	// workflows that this action triggers. You create custom workflows by assigning
	// AWS Lambda functions to user pool triggers. When you use the
	// RespondToAuthChallenge API action, Amazon Cognito invokes any functions that are
	// assigned to the following triggers: post authentication, pre token generation,
	// define auth challenge, create auth challenge, and verify auth challenge. When
	// Amazon Cognito invokes any of these functions, it passes a JSON payload, which
	// the function receives as input. This payload contains a clientMetadata
	// attribute, which provides the data that you assigned to the ClientMetadata
	// parameter in your RespondToAuthChallenge request. In your function code in AWS
	// Lambda, you can process the clientMetadata value to enhance your workflow for
	// your specific needs. For more information, see Customizing User Pool Workflows
	// with Lambda Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]string

	// The session which should be passed both ways in challenge-response calls to the
	// service. If InitiateAuth or RespondToAuthChallenge API call determines that the
	// caller needs to go through another challenge, they return a session with other
	// challenge parameters. This session should be passed as it is to the next
	// RespondToAuthChallenge API call.
	Session *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.
	UserContextData *types.UserContextDataType
}

type RespondToAuthChallengeOutput struct {

	// The result returned by the server in response to the request to respond to the
	// authentication challenge.
	AuthenticationResult *types.AuthenticationResultType

	// The challenge name. For more information, see InitiateAuth
	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html).
	ChallengeName types.ChallengeNameType

	// The challenge parameters. For more information, see InitiateAuth
	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_InitiateAuth.html).
	ChallengeParameters map[string]string

	// The session which should be passed both ways in challenge-response calls to the
	// service. If the caller needs to go through another challenge, they return a
	// session with other challenge parameters. This session should be passed as it is
	// to the next RespondToAuthChallenge API call.
	Session *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type SetRiskConfigurationInput struct {

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The account takeover risk configuration.
	AccountTakeoverRiskConfiguration *types.AccountTakeoverRiskConfigurationType

	// The app client ID. If ClientId is null, then the risk configuration is mapped to
	// userPoolId. When the client ID is null, the same risk configuration is applied
	// to all the clients in the userPool. Otherwise, ClientId is mapped to the client.
	// When the client ID is not null, the user pool configuration is overridden and
	// the risk configuration for the client is used instead.
	ClientId *string

	// The compromised credentials risk configuration.
	CompromisedCredentialsRiskConfiguration *types.CompromisedCredentialsRiskConfigurationType

	// The configuration to override the risk decision.
	RiskExceptionConfiguration *types.RiskExceptionConfigurationType
}

type SetRiskConfigurationOutput struct {

	// The risk configuration.
	//
	// This member is required.
	RiskConfiguration *types.RiskConfigurationType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type SetUICustomizationInput struct {

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string

	// The CSS values in the UI customization.
	CSS *string

	// The client ID for the client app.
	ClientId *string

	// The uploaded logo image for the UI customization.
	ImageFile []byte
}

type SetUICustomizationOutput struct {

	// The UI customization information.
	//
	// This member is required.
	UICustomization *types.UICustomizationType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type SetUserMFAPreferenceInput struct {

	// The access token for the user.
	//
	// This member is required.
	AccessToken *string

	// The SMS text message multi-factor authentication (MFA) settings.
	SMSMfaSettings *types.SMSMfaSettingsType

	// The time-based one-time password software token MFA settings.
	SoftwareTokenMfaSettings *types.SoftwareTokenMfaSettingsType
}

type SetUserMFAPreferenceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type SetUserPoolMfaConfigInput struct {

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The MFA configuration. Valid values include:
	//
	// * OFF MFA will not be used for any
	// users.
	//
	// * ON MFA is required for all users to sign in.
	//
	// * OPTIONAL MFA will be
	// required only for individual users who have an MFA factor enabled.
	MfaConfiguration types.UserPoolMfaType

	// The SMS text message MFA configuration.
	SmsMfaConfiguration *types.SmsMfaConfigType

	// The software token MFA configuration.
	SoftwareTokenMfaConfiguration *types.SoftwareTokenMfaConfigType
}

type SetUserPoolMfaConfigOutput struct {

	// The MFA configuration. Valid values include:
	//
	// * OFF MFA will not be used for any
	// users.
	//
	// * ON MFA is required for all users to sign in.
	//
	// * OPTIONAL MFA will be
	// required only for individual users who have an MFA factor enabled.
	MfaConfiguration types.UserPoolMfaType

	// The SMS text message MFA configuration.
	SmsMfaConfiguration *types.SmsMfaConfigType

	// The software token MFA configuration.
	SoftwareTokenMfaConfiguration *types.SoftwareTokenMfaConfigType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type SetUserSettingsInput struct {

	// The access token for the set user settings request.
	//
	// This member is required.
	AccessToken *string

	// You can use this parameter only to set an SMS configuration that uses SMS for
	// delivery.
	//
	// This member is required.
	MFAOptions []types.MFAOptionType
}

type SetUserSettingsOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type SignUpInput struct {

	// The ID of the client associated with the user pool.
	//
	// This member is required.
	ClientId *string

	// The password of the user you wish to register.
	//
	// This member is required.
	Password *string

	// The user name of the user you wish to register.
	//
	// This member is required.
	Username *string

	// The Amazon Pinpoint analytics metadata for collecting metrics for SignUp calls.
	AnalyticsMetadata *types.AnalyticsMetadataType

	// A map of custom key-value pairs that you can provide as input for any custom
	// workflows that this action triggers. You create custom workflows by assigning
	// AWS Lambda functions to user pool triggers. When you use the SignUp API action,
	// Amazon Cognito invokes any functions that are assigned to the following
	// triggers: pre sign-up, custom message, and post confirmation. When Amazon
	// Cognito invokes any of these functions, it passes a JSON payload, which the
	// function receives as input. This payload contains a clientMetadata attribute,
	// which provides the data that you assigned to the ClientMetadata parameter in
	// your SignUp request. In your function code in AWS Lambda, you can process the
	// clientMetadata value to enhance your workflow for your specific needs. For more
	// information, see Customizing User Pool Workflows with Lambda Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]string

	// A keyed-hash message authentication code (HMAC) calculated using the secret key
	// of a user pool client and username plus the client ID in the message.
	SecretHash *string

	// An array of name-value pairs representing user attributes. For custom
	// attributes, you must prepend the custom: prefix to the attribute name.
	UserAttributes []types.AttributeType

	// 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.
	UserContextData *types.UserContextDataType

	// The validation data in the request to register a user.
	ValidationData []types.AttributeType
}

type SignUpOutput struct {

	// A response from the server indicating that a user registration has been
	// confirmed.
	//
	// This member is required.
	UserConfirmed bool

	// The UUID of the authenticated user. This is not the same as username.
	//
	// This member is required.
	UserSub *string

	// The code delivery details returned by the server response to the user
	// registration request.
	CodeDeliveryDetails *types.CodeDeliveryDetailsType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type StartUserImportJobInput struct {

	// The job ID for the user import job.
	//
	// This member is required.
	JobId *string

	// The user pool ID for the user pool that the users are being imported into.
	//
	// This member is required.
	UserPoolId *string
}

type StartUserImportJobOutput struct {

	// The job object that represents the user import job.
	UserImportJob *types.UserImportJobType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type StopUserImportJobInput struct {

	// The job ID for the user import job.
	//
	// This member is required.
	JobId *string

	// The user pool ID for the user pool that the users are being imported into.
	//
	// This member is required.
	UserPoolId *string
}

type StopUserImportJobOutput struct {

	// The job object that represents the user import job.
	UserImportJob *types.UserImportJobType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type TagResourceInput struct {

	// The Amazon Resource Name (ARN) of the user pool to assign the tags to.
	//
	// This member is required.
	ResourceArn *string

	// The tags to assign to the user pool.
	//
	// This member is required.
	Tags map[string]string
}

type TagResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UntagResourceInput struct {

	// The Amazon Resource Name (ARN) of the user pool that the tags are assigned to.
	//
	// This member is required.
	ResourceArn *string

	// The keys of the tags to remove from the user pool.
	//
	// This member is required.
	TagKeys []string
}

type UntagResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateAuthEventFeedbackInput struct {

	// The event ID.
	//
	// This member is required.
	EventId *string

	// The feedback token.
	//
	// This member is required.
	FeedbackToken *string

	// The authentication event feedback value.
	//
	// This member is required.
	FeedbackValue types.FeedbackValueType

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The user pool username.
	//
	// This member is required.
	Username *string
}

type UpdateAuthEventFeedbackOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateDeviceStatusInput struct {

	// The access token.
	//
	// This member is required.
	AccessToken *string

	// The device key.
	//
	// This member is required.
	DeviceKey *string

	// The status of whether a device is remembered.
	DeviceRememberedStatus types.DeviceRememberedStatusType
}

type UpdateDeviceStatusOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateGroupInput struct {

	// The name of the group.
	//
	// This member is required.
	GroupName *string

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string

	// A string containing the new description of the group.
	Description *string

	// The new precedence value for the group. For more information about this
	// parameter, see CreateGroup
	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_CreateGroup.html).
	Precedence *int32

	// The new role ARN for the group. This is used for setting the cognito:roles and
	// cognito:preferred_role claims in the token.
	RoleArn *string
}

type UpdateGroupOutput struct {

	// The group object for the group.
	Group *types.GroupType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateIdentityProviderInput struct {

	// The identity provider name.
	//
	// This member is required.
	ProviderName *string

	// The user pool ID.
	//
	// This member is required.
	UserPoolId *string

	// The identity provider attribute mapping to be changed.
	AttributeMapping map[string]string

	// A list of identity provider identifiers.
	IdpIdentifiers []string

	// The identity provider details to be updated, such as MetadataURL and
	// MetadataFile.
	ProviderDetails map[string]string
}

type UpdateIdentityProviderOutput struct {

	// The identity provider object.
	//
	// This member is required.
	IdentityProvider *types.IdentityProviderType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateResourceServerInput struct {

	// The identifier for the resource server.
	//
	// This member is required.
	Identifier *string

	// The name of the resource server.
	//
	// This member is required.
	Name *string

	// The user pool ID for the user pool.
	//
	// This member is required.
	UserPoolId *string

	// The scope values to be set for the resource server.
	Scopes []types.ResourceServerScopeType
}

type UpdateResourceServerOutput struct {

	// The resource server.
	//
	// This member is required.
	ResourceServer *types.ResourceServerType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateUserAttributesInput struct {

	// The access token for the request to update user attributes.
	//
	// This member is required.
	AccessToken *string

	// An array of name-value pairs representing user attributes. For custom
	// attributes, you must prepend the custom: prefix to the attribute name.
	//
	// This member is required.
	UserAttributes []types.AttributeType

	// A map of custom key-value pairs that you can provide as input for any custom
	// workflows that this action triggers. You create custom workflows by assigning
	// AWS Lambda functions to user pool triggers. When you use the
	// UpdateUserAttributes API action, Amazon Cognito invokes the function that is
	// assigned to the custom message trigger. When Amazon Cognito invokes this
	// function, it passes a JSON payload, which the function receives as input. This
	// payload contains a clientMetadata attribute, which provides the data that you
	// assigned to the ClientMetadata parameter in your UpdateUserAttributes request.
	// In your function code in AWS Lambda, you can process the clientMetadata value to
	// enhance your workflow for your specific needs. For more information, see
	// Customizing User Pool Workflows with Lambda Triggers
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html)
	// in the Amazon Cognito Developer Guide. Take the following limitations into
	// consideration when you use the ClientMetadata parameter:
	//
	// * Amazon Cognito does
	// not store the ClientMetadata value. This data is available only to AWS Lambda
	// triggers that are assigned to a user pool to support custom workflows. If your
	// user pool configuration does not include triggers, the ClientMetadata parameter
	// serves no purpose.
	//
	// * Amazon Cognito does not validate the ClientMetadata
	// value.
	//
	// * Amazon Cognito does not encrypt the the ClientMetadata value, so don't
	// use it to provide sensitive information.
	ClientMetadata map[string]string
}

type UpdateUserAttributesOutput struct {

	// The code delivery details list from the server for the request to update user
	// attributes.
	CodeDeliveryDetailsList []types.CodeDeliveryDetailsType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateUserPoolClientInput struct {

	// The ID of the client associated with the user pool.
	//
	// This member is required.
	ClientId *string

	// The user pool ID for the user pool where you want to update the user pool
	// client.
	//
	// This member is required.
	UserPoolId *string

	// The time limit, 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 []types.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 collecting metrics for this 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.
	AnalyticsConfiguration *types.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 client name from the update user pool client request.
	ClientName *string

	// 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 []types.ExplicitAuthFlowsType

	// The time limit, after which the ID token is no longer valid and cannot be used.
	IdTokenValidity *int32

	// 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 types.PreventUserExistenceErrorTypes

	// The read-only attributes of the user pool.
	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 units in which the validity times are represented in. Default for
	// RefreshToken is days, and default for ID and access tokens are hours.
	TokenValidityUnits *types.TokenValidityUnitsType

	// The writeable attributes of the user pool.
	WriteAttributes []string
}

type UpdateUserPoolClientOutput struct {

	// The user pool client value from the response from the server when an update user
	// pool client request is made.
	UserPoolClient *types.UserPoolClientType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateUserPoolDomainInput struct {

	// The configuration for a custom domain that hosts the sign-up and sign-in pages
	// for your application. Use this object to specify an SSL certificate that is
	// managed by ACM.
	//
	// This member is required.
	CustomDomainConfig *types.CustomDomainConfigType

	// The domain name for the custom domain that hosts the sign-up and sign-in pages
	// for your application. For example: auth.example.com. This string can include
	// only lowercase letters, numbers, and hyphens. Do not use a hyphen for the first
	// or last character. Use periods to separate subdomain names.
	//
	// This member is required.
	Domain *string

	// The ID of the user pool that is associated with the custom domain that you are
	// updating the certificate for.
	//
	// This member is required.
	UserPoolId *string
}

type UpdateUserPoolDomainOutput struct {

	// The Amazon CloudFront endpoint that Amazon Cognito set up when you added the
	// custom domain to your user pool.
	CloudFrontDomain *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateUserPoolInput struct {

	// The user pool ID for the user pool you want to update.
	//
	// This member is required.
	UserPoolId *string

	// 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 *types.AccountRecoverySettingType

	// The configuration for AdminCreateUser requests.
	AdminCreateUserConfig *types.AdminCreateUserConfigType

	// The attributes that are automatically verified when the Amazon Cognito service
	// makes a request to update user pools.
	AutoVerifiedAttributes []types.VerifiedAttributeType

	// Device configuration.
	DeviceConfiguration *types.DeviceConfigurationType

	// Email configuration.
	EmailConfiguration *types.EmailConfigurationType

	// The contents of the email verification message.
	EmailVerificationMessage *string

	// The subject of the email verification message.
	EmailVerificationSubject *string

	// The AWS Lambda configuration information from the request to update the user
	// pool.
	LambdaConfig *types.LambdaConfigType

	// 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 types.UserPoolMfaType

	// A container with the policies you wish to update in a user pool.
	Policies *types.UserPoolPolicyType

	// The contents of the SMS authentication message.
	SmsAuthenticationMessage *string

	// SMS configuration.
	SmsConfiguration *types.SmsConfigurationType

	// A container with information about the SMS verification message.
	SmsVerificationMessage *string

	// Used to enable advanced security risk detection. Set the key
	// AdvancedSecurityMode to the value "AUDIT".
	UserPoolAddOns *types.UserPoolAddOnsType

	// The tag keys and values to assign to the user pool. A tag is a label that you
	// can use to categorize and manage user pools in different ways, such as by
	// purpose, owner, environment, or other criteria.
	UserPoolTags map[string]string

	// The template for verification messages.
	VerificationMessageTemplate *types.VerificationMessageTemplateType
}

type UpdateUserPoolOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type VerifySoftwareTokenInput struct {

	// The one time password computed using the secret code returned by
	// AssociateSoftwareToken"
	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AssociateSoftwareToken.html).
	//
	// This member is required.
	UserCode *string

	// The access token.
	AccessToken *string

	// The friendly device name.
	FriendlyDeviceName *string

	// The session which should be passed both ways in challenge-response calls to the
	// service.
	Session *string
}

type VerifySoftwareTokenOutput struct {

	// The session which should be passed both ways in challenge-response calls to the
	// service.
	Session *string

	// The status of the verify software token.
	Status types.VerifySoftwareTokenResponseType

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type VerifyUserAttributeInput struct {

	// Represents the access token of the request to verify user attributes.
	//
	// This member is required.
	AccessToken *string

	// The attribute name in the request to verify user attributes.
	//
	// This member is required.
	AttributeName *string

	// The verification code in the request to verify user attributes.
	//
	// This member is required.
	Code *string
}

type VerifyUserAttributeOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}