cognitoidentityprovider

type AddCustomAttributesInput struct {
	// The user pool ID for the user pool where you want to add custom attributes.
	UserPoolId *string
	// An array of custom attributes, such as Mutable and Name.
	CustomAttributes []*types.SchemaAttributeType
}

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

type AdminAddUserToGroupInput struct {
	// The user pool ID for the user pool.
	UserPoolId *string
	// The group name.
	GroupName *string
	// The username for the user.
	Username *string
}

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

type AdminConfirmSignUpInput struct {
	// The user name for which you want to confirm user registration.
	Username *string
	// The user pool ID for which you want to confirm user registration.
	UserPoolId *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 {
	// 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
	// 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 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
	// The user pool ID for the user pool where the user will be created.
	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.
	Username *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 (in 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 .)
	//
	//
	// * 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 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
	// 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
}

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.
	UserAttributeNames []*string
	// The user pool ID for the user pool where you want to delete user attributes.
	UserPoolId *string
	// The user name of the user from which you would like to delete attributes.
	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.
	UserPoolId *string
	// The user name of the user you wish to delete.
	Username *string
}

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

type AdminDisableProviderForUserInput struct {
	// The user to be disabled.
	User *types.ProviderUserIdentifierType
	// The user pool ID for the user pool.
	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.
	UserPoolId *string
	// The user name of the user you wish to disable.
	Username *string
}

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

type AdminEnableUserInput struct {
	// The user name of the user you wish to enable.
	Username *string
	// The user pool ID for the user pool where you want to enable the user.
	UserPoolId *string
}

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

type AdminForgetDeviceInput struct {
	// The device key.
	DeviceKey *string
	// The user name.
	Username *string
	// The user pool ID.
	UserPoolId *string
}

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

type AdminGetDeviceInput struct {
	// The user name.
	Username *string
	// The device key.
	DeviceKey *string
	// The user pool ID.
	UserPoolId *string
}

type AdminGetDeviceOutput struct {
	// The device.
	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.
	UserPoolId *string
	// The user name of the user you wish to retrieve.
	Username *string
}

type AdminGetUserOutput struct {
	// The user's preferred MFA setting.
	PreferredMfaSetting *string
	// The date the user was created.
	UserCreateDate *time.Time
	// The user name of the user about whom you are receiving information.
	Username *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
	// Indicates that the status is enabled.
	Enabled *bool
	// An array of name-value pairs representing user attributes.
	UserAttributes []*types.AttributeType
	// 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
	// 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 the AdminGetUserResponse$UserMFASettingList () response
	// instead.
	MFAOptions []*types.MFAOptionType
	// The date the user was last modified.
	UserLastModifiedDate *time.Time

	// 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.
	AuthFlow types.AuthFlowType
	// The ID of the Amazon Cognito user pool.
	UserPoolId *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
	//
	//     <p>When Amazon Cognito invokes the
	// functions for these triggers, it passes a JSON payload, which the function
	// receives as input. This payload contains a <code>validationData</code>
	// 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 <code>validationData</code> value to enhance your
	// workflow for your specific needs.</p> <p>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:</p> <ul> <li> <p>Post
	// authentication</p> </li> <li> <p>Custom message</p> </li> <li> <p>Pre token
	// generation</p> </li> <li> <p>Create auth challenge</p> </li> <li> <p>Define auth
	// challenge</p> </li> <li> <p>Verify auth challenge</p> </li> </ul> <p>For more
	// information, see <a
	// href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html">Customizing
	// User Pool Workflows with Lambda Triggers</a> in the <i>Amazon Cognito Developer
	// Guide</i>.</p> <note> <p>Take the following limitations into consideration when
	// you use the ClientMetadata parameter:</p> <ul> <li> <p>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.</p> </li> <li> <p>Amazon Cognito does not validate the
	// ClientMetadata value.</p> </li> <li> <p>Amazon Cognito does not encrypt the the
	// ClientMetadata value, so don't use it to provide sensitive information.</p>
	// </li> </ul> </note>
	ClientMetadata map[string]*string
	// The analytics metadata for collecting Amazon Pinpoint metrics for
	// AdminInitiateAuth calls.
	AnalyticsMetadata *types.AnalyticsMetadataType
	// 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 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
	AuthParameters map[string]*string
	// The app client ID.
	ClientId *string
}

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 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
	// 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

	// 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.
	DestinationUser *types.ProviderUserIdentifierType
	// The user pool ID for the user pool.
	UserPoolId *string
	// 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.
	SourceUser *types.ProviderUserIdentifierType
}

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

type AdminListDevicesInput struct {
	// The user pool ID.
	UserPoolId *string
	// The user name.
	Username *string
	// The pagination token.
	PaginationToken *string
	// The limit of the devices request.
	Limit *int32
}

type AdminListDevicesOutput struct {
	// The pagination token.
	PaginationToken *string
	// The devices in the list of devices response.
	Devices []*types.DeviceType

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

type AdminListGroupsForUserInput struct {
	// The user pool ID for the user pool.
	UserPoolId *string
	// The username for the user.
	Username *string
	// 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 limit of the request to list groups.
	Limit *int32
}

type AdminListGroupsForUserOutput 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 groups that the user belongs to.
	Groups []*types.GroupType

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

type AdminListUserAuthEventsInput struct {
	// The maximum number of authentication events to return.
	MaxResults *int32
	// A pagination token.
	NextToken *string
	// The user pool username or an alias.
	Username *string
	// The user pool ID.
	UserPoolId *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 AdminRemoveUserFromGroupInput struct {
	// The username for the user.
	Username *string
	// The user pool ID for the user pool.
	UserPoolId *string
	// The group name.
	GroupName *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.
	UserPoolId *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
	// The user name of the user whose password you wish to reset.
	Username *string
}

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

type AdminRespondToAuthChallengeInput struct {
	// 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
	// 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
	// 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 challenge name. For more information, see .
	ChallengeName types.ChallengeNameType
	// The analytics metadata for collecting Amazon Pinpoint metrics for
	// AdminRespondToAuthChallenge calls.
	AnalyticsMetadata *types.AnalyticsMetadataType
	// 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
	// The ID of the Amazon Cognito user pool.
	UserPoolId *string
	// The app client ID.
	ClientId *string
}

type AdminRespondToAuthChallengeOutput struct {
	// The challenge parameters. For more information, see .
	ChallengeParameters map[string]*string
	// The result returned by the server in response to the authentication request.
	AuthenticationResult *types.AuthenticationResultType
	// The name of the challenge. For more information, see .
	ChallengeName types.ChallengeNameType
	// The session which should be passed both ways in challenge-response calls to the
	// service. If the or 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

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

type AdminSetUserMFAPreferenceInput struct {
	// The SMS text message MFA settings.
	SMSMfaSettings *types.SMSMfaSettingsType
	// The user pool ID.
	UserPoolId *string
	// The user pool username or alias.
	Username *string
	// 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 user pool ID for the user pool where you want to set the user's password.
	UserPoolId *string
	// The password for the user.
	Password *string
	// True if the password is permanent, False if it is temporary.
	Permanent *bool
	// The user name of the user whose password you wish to set.
	Username *string
}

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

type AdminSetUserSettingsInput struct {
	// The user name of the user that you are setting options for.
	Username *string
	// You can use this parameter only to set an SMS configuration that uses SMS for
	// delivery.
	MFAOptions []*types.MFAOptionType
	// The ID of the user pool that contains the user that you are setting options for.
	UserPoolId *string
}

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

type AdminUpdateAuthEventFeedbackInput struct {
	// The user pool username.
	Username *string
	// The authentication event feedback value.
	FeedbackValue types.FeedbackValueType
	// The authentication event ID.
	EventId *string
	// The user pool ID.
	UserPoolId *string
}

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

type AdminUpdateDeviceStatusInput struct {
	// The user pool ID.
	UserPoolId *string
	// The status indicating whether a device has been remembered or not.
	DeviceRememberedStatus types.DeviceRememberedStatusType
	// The user name.
	Username *string
	// The device key.
	DeviceKey *string
}

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

type AdminUpdateUserAttributesInput struct {
	// 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
	// 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
	// The user pool ID for the user pool where you want to update user attributes.
	UserPoolId *string
	// The user name of the user for whom you want to update user attributes.
	Username *string
}

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

type AdminUserGlobalSignOutInput struct {
	// The user name.
	Username *string
	// The user pool ID.
	UserPoolId *string
}

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

type AssociateSoftwareTokenInput struct {
	// 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
	// The access token.
	AccessToken *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 old password.
	PreviousPassword *string
	// The access token.
	AccessToken *string
	// The new password.
	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.
	AccessToken *string
	// The device name.
	DeviceName *string
	// The device key.
	DeviceKey *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 {
	// 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
	// The app client ID of the app associated with the user pool.
	ClientId *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
	// 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
	// The confirmation code sent by a user's request to retrieve a forgotten password.
	// For more information, see
	ConfirmationCode *string
	// The user name of the user for whom you want to enter a code to retrieve a
	// forgotten password.
	Username *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
	// The password sent by a user's request to retrieve a forgotten password.
	Password *string
	// The Amazon Pinpoint analytics metadata for collecting metrics for
	// ConfirmForgotPassword calls.
	AnalyticsMetadata *types.AnalyticsMetadataType
}

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

type ConfirmSignUpInput struct {
	// 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 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
	// 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
	// The ID of the app client associated with the user pool.
	ClientId *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
	// The confirmation code sent by a user's request to confirm registration.
	ConfirmationCode *string
	// The user name of the user whose registration you wish to confirm.
	Username *string
	// The Amazon Pinpoint analytics metadata for collecting metrics for ConfirmSignUp
	// calls.
	AnalyticsMetadata *types.AnalyticsMetadataType
}

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

type CreateGroupInput struct {
	// 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 name of the group. Must be unique.
	GroupName *string
	// The user pool ID for the user pool.
	UserPoolId *string
	// The role ARN for the group.
	RoleArn *string
	// A string containing the description of the group.
	Description *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 user pool ID.
	UserPoolId *string
	// The identity provider type.
	ProviderType types.IdentityProviderTypeType
	// 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
	// The identity provider name.
	ProviderName *string
	// The identity provider details. The following list describes the provider detail
	// keys for each identity provider type.
	//
	//     * For Google, Facebook and Login with
	// Amazon:
	//
	//         * client_id
	//
	//         * client_secret
	//
	//         *
	// authorize_scopes
	//
	//     * For Sign in with Apple:
	//
	//         * client_id
	//
	//         *
	// team_id
	//
	//         * key_id
	//
	//         * private_key
	//
	//         * authorize_scopes
	//
	//
	// * For OIDC providers:
	//
	//         * client_id
	//
	//         * client_secret
	//
	//         *
	// attributes_request_method
	//
	//         * oidc_issuer
	//
	//         * authorize_scopes
	//
	//
	// * authorize_url if not available from discovery URL specified by oidc_issuer
	// key
	//
	//         * token_url if not available from discovery URL specified by
	// oidc_issuer key
	//
	//         * attributes_url if not available from discovery URL
	// specified by oidc_issuer key
	//
	//         * jwks_uri if not available from discovery
	// URL specified by oidc_issuer key
	//
	//         * authorize_scopes
	//
	//     * For SAML
	// providers:
	//
	//         * MetadataFile OR MetadataURL
	//
	//         * IDPSignout optional
	ProviderDetails map[string]*string
}

type CreateIdentityProviderOutput struct {
	// The newly created identity provider object.
	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.
	Identifier *string
	// A list of scopes. Each scope is map, where the keys are name and description.
	Scopes []*types.ResourceServerScopeType
	// A friendly name for the resource server.
	Name *string
	// The user pool ID for the user pool.
	UserPoolId *string
}

type CreateResourceServerOutput struct {
	// The newly created resource server.
	ResourceServer *types.ResourceServerType

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

type CreateUserImportJobInput struct {
	// The user pool ID for the user pool that the users are being imported into.
	UserPoolId *string
	// The role ARN for the Amazon CloudWatch Logging role for the user import job.
	CloudWatchLogsRoleArn *string
	// The job name for the user import job.
	JobName *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 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 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
	// The user pool ID for the user pool where you want to create a user pool client.
	UserPoolId *string
	// The client name for the user pool client you would like to create.
	ClientName *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.
	//
	// This
	// setting affects the behavior of following APIs:
	//
	//     * AdminInitiateAuth ()
	//
	//
	// * AdminRespondToAuthChallenge ()
	//
	//     * InitiateAuth ()
	//
	//     *
	// RespondToAuthChallenge ()
	//
	//     * ForgotPassword ()
	//
	//     * ConfirmForgotPassword
	// ()
	//
	//     * ConfirmSignUp ()
	//
	//     * ResendConfirmationCode ()
	//
	// 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 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
	// 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
	// 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
	// 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
	// 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
	// Set to true if the client is allowed to follow the OAuth protocol when
	// interacting with Cognito user pools.
	AllowedOAuthFlowsUserPoolClient *bool
	// The Amazon Pinpoint analytics configuration for collecting metrics for this user
	// pool. Cognito User Pools only supports sending events to Amazon Pinpoint
	// projects in the US East (N. Virginia) us-east-1 Region, regardless of the region
	// in which the user pool resides.
	AnalyticsConfiguration *types.AnalyticsConfigurationType
	// A list of allowed logout URLs for the identity providers.
	LogoutURLs []*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
}

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.
	Domain *string
	// The user pool ID.
	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 {
	// The email configuration.
	EmailConfiguration *types.EmailConfigurationType
	// The configuration for AdminCreateUser requests.
	AdminCreateUserConfig *types.AdminCreateUserConfigType
	// A string representing the email verification message.
	EmailVerificationMessage *string
	// The device configuration.
	DeviceConfiguration *types.DeviceConfigurationType
	// The SMS configuration.
	SmsConfiguration *types.SmsConfigurationType
	// 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
	// A string representing the email verification subject.
	EmailVerificationSubject *string
	// Used to enable advanced security risk detection. Set the key
	// AdvancedSecurityMode to the value "AUDIT".
	UserPoolAddOns *types.UserPoolAddOnsType
	// 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
	// The attributes to be auto-verified. Possible values: email, phone_number.
	AutoVerifiedAttributes []types.VerifiedAttributeType
	// A string representing the SMS authentication message.
	SmsAuthenticationMessage *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. Starting February 1, 2020, the value of AccountRecoverySetting will
	// default to verified_email first and verified_phone_number as the second option
	// for newly created user pools if no value is provided.
	AccountRecoverySetting *types.AccountRecoverySettingType
	// Specifies whether email addresses or phone numbers can be specified as usernames
	// when a user signs up.
	UsernameAttributes []types.UsernameAttributeType
	// 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
	// The template for the verification message that the user sees when the app
	// requests permission to access the user's information.
	VerificationMessageTemplate *types.VerificationMessageTemplateType
	// A string used to name the user pool.
	PoolName *string
	// 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 .
	UsernameConfiguration *types.UsernameConfigurationType
	// Attributes supported as an alias for this user pool. Possible values:
	// phone_number, email, or preferred_username.
	AliasAttributes []types.AliasAttributeType
	// A string representing the SMS verification message.
	SmsVerificationMessage *string
	// Specifies MFA configuration details.
	MfaConfiguration types.UserPoolMfaType
}

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 user pool ID for the user pool.
	UserPoolId *string
	// The name of the group.
	GroupName *string
}

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

type DeleteIdentityProviderInput struct {
	// The identity provider name.
	ProviderName *string
	// The user pool ID.
	UserPoolId *string
}

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

type DeleteResourceServerInput struct {
	// The user pool ID for the user pool that hosts the resource server.
	UserPoolId *string
	// The identifier for the resource server.
	Identifier *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.
	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.
	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.
	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.
	ClientId *string
	// The user pool ID for the user pool where you want to delete the client.
	UserPoolId *string
}

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

type DeleteUserPoolDomainInput struct {
	// The domain string.
	Domain *string
	// The user pool ID.
	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.
	UserPoolId *string
}

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

type DescribeIdentityProviderInput struct {
	// The identity provider name.
	ProviderName *string
	// The user pool ID.
	UserPoolId *string
}

type DescribeIdentityProviderOutput struct {
	// The identity provider that was deleted.
	IdentityProvider *types.IdentityProviderType

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

type DescribeResourceServerInput struct {
	// The identifier for the resource server
	Identifier *string
	// The user pool ID for the user pool that hosts the resource server.
	UserPoolId *string
}

type DescribeResourceServerOutput struct {
	// The resource server.
	ResourceServer *types.ResourceServerType

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

type DescribeRiskConfigurationInput struct {
	// The app client ID.
	ClientId *string
	// The user pool ID.
	UserPoolId *string
}

type DescribeRiskConfigurationOutput struct {
	// The risk configuration.
	RiskConfiguration *types.RiskConfigurationType

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

type DescribeUserImportJobInput struct {
	// The job ID for the user import job.
	JobId *string
	// The user pool ID for the user pool that the users are being imported into.
	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.
	ClientId *string
	// The user pool ID for the user pool you want to describe.
	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.
	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.
	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 ResolverOptions) (aws.Endpoint, error)
}

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

type ForgetDeviceInput struct {
	// The device key.
	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 user name of the user for whom you want to enter a code to reset a forgotten
	// password.
	Username *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
	// 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
	// The Amazon Pinpoint analytics metadata for collecting metrics for ForgotPassword
	// calls.
	AnalyticsMetadata *types.AnalyticsMetadataType
	// 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
	// The ID of the client associated with the user pool.
	ClientId *string
}

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.
	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 access token.
	AccessToken *string
	// The device key.
	DeviceKey *string
}

type GetDeviceOutput struct {
	// The device.
	Device *types.DeviceType

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

type GetGroupInput struct {
	// The user pool ID for the user pool.
	UserPoolId *string
	// The name of the group.
	GroupName *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 user pool ID.
	UserPoolId *string
	// The identity provider ID.
	IdpIdentifier *string
}

type GetIdentityProviderByIdentifierOutput struct {
	// The identity provider object.
	IdentityProvider *types.IdentityProviderType

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

type GetSigningCertificateInput struct {
	// The user pool ID.
	UserPoolId *string
}

type GetSigningCertificateOutput struct {
	// The signing certificate.
	Certificate *string

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

type GetUICustomizationInput struct {
	// The client ID for the client app.
	ClientId *string
	// The user pool ID for the user pool.
	UserPoolId *string
}

type GetUICustomizationOutput struct {
	// The UI customization information.
	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.
	AccessToken *string
	// The attribute name returned by the server response to get the user attribute
	// verification code.
	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.
	AccessToken *string
}

type GetUserOutput struct {
	// The user name of the user you wish to retrieve from the get user request.
	Username *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
	// 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
	// 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 the use the GetUserResponse$UserMFASettingList () response
	// instead.
	MFAOptions []*types.MFAOptionType
	// The user's preferred MFA setting.
	PreferredMfaSetting *string

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

type GetUserPoolMfaConfigInput struct {
	// The user pool ID.
	UserPoolId *string
}

type GetUserPoolMfaConfigOutput struct {
	// The SMS text message multi-factor (MFA) configuration.
	SmsMfaConfiguration *types.SmsMfaConfigType
	// The software token multi-factor (MFA) configuration.
	SoftwareTokenMfaConfiguration *types.SoftwareTokenMfaConfigType
	// 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

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

type GlobalSignOutInput struct {
	// The access token.
	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 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
	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
	//
	//     <p>When Amazon Cognito invokes the functions for these
	// triggers, it passes a JSON payload, which the function receives as input. This
	// payload contains a <code>validationData</code> 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
	// <code>validationData</code> value to enhance your workflow for your specific
	// needs.</p> <p>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:</p> <ul> <li> <p>Post authentication</p> </li>
	// <li> <p>Custom message</p> </li> <li> <p>Pre token generation</p> </li> <li>
	// <p>Create auth challenge</p> </li> <li> <p>Define auth challenge</p> </li> <li>
	// <p>Verify auth challenge</p> </li> </ul> <p>For more information, see <a
	// href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html">Customizing
	// User Pool Workflows with Lambda Triggers</a> in the <i>Amazon Cognito Developer
	// Guide</i>.</p> <note> <p>Take the following limitations into consideration when
	// you use the ClientMetadata parameter:</p> <ul> <li> <p>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.</p> </li> <li> <p>Amazon Cognito does not validate the
	// ClientMetadata value.</p> </li> <li> <p>Amazon Cognito does not encrypt the the
	// ClientMetadata value, so don't use it to provide sensitive information.</p>
	// </li> </ul> </note>
	ClientMetadata map[string]*string
	// The Amazon Pinpoint analytics metadata for collecting metrics for InitiateAuth
	// calls.
	AnalyticsMetadata *types.AnalyticsMetadataType
	// The app client ID.
	ClientId *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
	// 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.
	AuthFlow types.AuthFlowType
}

type InitiateAuthOutput struct {
	// The session which should be passed both ways in challenge-response calls to the
	// service. If the or 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
	// 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 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 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

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

type ListDevicesInput struct {
	// The pagination token for the list request.
	PaginationToken *string
	// The limit of the device request.
	Limit *int32
	// The access tokens for the request to list devices.
	AccessToken *string
}

type ListDevicesOutput struct {
	// The pagination token for the list device response.
	PaginationToken *string
	// The devices returned in the list devices response.
	Devices []*types.DeviceType

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

type ListGroupsInput 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 ID for the user pool.
	UserPoolId *string
	// The limit of the request to list groups.
	Limit *int32
}

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 ListIdentityProvidersInput struct {
	// A pagination token.
	NextToken *string
	// The maximum number of identity providers to return.
	MaxResults *int32
	// The user pool ID.
	UserPoolId *string
}

type ListIdentityProvidersOutput struct {
	// A pagination token.
	NextToken *string
	// A list of identity provider objects.
	Providers []*types.ProviderDescription

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

type ListResourceServersInput struct {
	// A pagination token.
	NextToken *string
	// The user pool ID for the user pool.
	UserPoolId *string
	// The maximum number of resource servers to return.
	MaxResults *int32
}

type ListResourceServersOutput struct {
	// The resource servers.
	ResourceServers []*types.ResourceServerType
	// A pagination token.
	NextToken *string

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

type ListTagsForResourceInput struct {
	// The Amazon Resource Name (ARN) of the user pool that the tags are assigned to.
	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 user pool ID for the user pool that the users are being imported into.
	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
	// The maximum number of import jobs you want the request to return.
	MaxResults *int32
}

type ListUserImportJobsOutput struct {
	// The user import jobs.
	UserImportJobs []*types.UserImportJobType
	// An identifier that can be used to return the next set of user import jobs in the
	// list.
	PaginationToken *string

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

type ListUserPoolClientsInput struct {
	// The user pool ID for the user pool where you want to list user pool clients.
	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 ListUserPoolsInput 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 maximum number of results you want the request to return when listing the
	// user pools.
	MaxResults *int32
}

type ListUserPoolsOutput struct {
	// The user pools from the response to list users.
	UserPools []*types.UserPoolDescriptionType
	// 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 ListUsersInGroupInput struct {
	// The name of the group.
	GroupName *string
	// The user pool ID for the user pool.
	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 ListUsersInput struct {
	// 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
	// The user pool ID for the user pool on which the search should be performed.
	UserPoolId *string
	// 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
	// Maximum number of users to be returned.
	Limit *int32
	// 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
}

type ListUsersOutput struct {
	// The users returned in the request to list users.
	Users []*types.UserType
	// 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

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

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

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

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

	// The service endpoint resolver.
	EndpointResolver EndpointResolver

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// 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 {
	// 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 user name of the user to whom you wish to resend a confirmation code.
	Username *string
	// The ID of the client associated with the user pool.
	ClientId *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
	// 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
	// The Amazon Pinpoint analytics metadata for collecting metrics for
	// ResendConfirmationCode calls.
	AnalyticsMetadata *types.AnalyticsMetadataType
}

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  ResolverOptions
}

type ResolveEndpointMiddlewareOptions interface {
	GetEndpointResolver() EndpointResolver
	GetEndpointOptions() ResolverOptions
}

type ResolverOptions = internalendpoints.Options

type RespondToAuthChallengeInput struct {
	// 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
	// The app client ID.
	ClientId *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 challenge name. For more information, see . ADMIN_NO_SRP_AUTH is not a valid
	// value.
	ChallengeName types.ChallengeNameType
	// The Amazon Pinpoint analytics metadata for collecting metrics for
	// RespondToAuthChallenge calls.
	AnalyticsMetadata *types.AnalyticsMetadataType
	// 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 .
	ChallengeName types.ChallengeNameType
	// The session which should be passed both ways in challenge-response calls to the
	// service. If the or 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
	// The challenge parameters. For more information, see .
	ChallengeParameters map[string]*string

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

type SetRiskConfigurationInput struct {
	// The configuration to override the risk decision.
	RiskExceptionConfiguration *types.RiskExceptionConfigurationType
	// The account takeover risk configuration.
	AccountTakeoverRiskConfiguration *types.AccountTakeoverRiskConfigurationType
	// The user pool ID.
	UserPoolId *string
	// The compromised credentials risk configuration.
	CompromisedCredentialsRiskConfiguration *types.CompromisedCredentialsRiskConfigurationType
	// 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
}

type SetRiskConfigurationOutput struct {
	// The risk configuration.
	RiskConfiguration *types.RiskConfigurationType

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

type SetUICustomizationInput struct {
	// The client ID for the client app.
	ClientId *string
	// The user pool ID for the user pool.
	UserPoolId *string
	// The CSS values in the UI customization.
	CSS *string
	// The uploaded logo image for the UI customization.
	ImageFile []byte
}

type SetUICustomizationOutput struct {
	// The UI customization information.
	UICustomization *types.UICustomizationType

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

type SetUserMFAPreferenceInput struct {
	// The access token for the user.
	AccessToken *string
	// The time-based one-time password software token MFA settings.
	SoftwareTokenMfaSettings *types.SoftwareTokenMfaSettingsType
	// The SMS text message multi-factor authentication (MFA) settings.
	SMSMfaSettings *types.SMSMfaSettingsType
}

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

type SetUserPoolMfaConfigInput struct {
	// The user pool ID.
	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 software token MFA configuration.
	SoftwareTokenMfaConfiguration *types.SoftwareTokenMfaConfigType
	// The SMS text message MFA configuration.
	SmsMfaConfiguration *types.SmsMfaConfigType
}

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 software token MFA configuration.
	SoftwareTokenMfaConfiguration *types.SoftwareTokenMfaConfigType
	// The SMS text message MFA configuration.
	SmsMfaConfiguration *types.SmsMfaConfigType

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

type SetUserSettingsInput struct {
	// The access token for the set user settings request.
	AccessToken *string
	// You can use this parameter only to set an SMS configuration that uses SMS for
	// delivery.
	MFAOptions []*types.MFAOptionType
}

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

type SignUpInput struct {
	// The user name of the user you wish to register.
	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 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
	// The password of the user you wish to register.
	Password *string
	// The Amazon Pinpoint analytics metadata for collecting metrics for SignUp calls.
	AnalyticsMetadata *types.AnalyticsMetadataType
	// 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
	// The ID of the client associated with the user pool.
	ClientId *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
	// 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
	// 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.
	UserConfirmed *bool
	// The UUID of the authenticated user. This is not the same as username.
	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.
	JobId *string
	// The user pool ID for the user pool that the users are being imported into.
	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.
	JobId *string
	// The user pool ID for the user pool that the users are being imported into.
	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 tags to assign to the user pool.
	Tags map[string]*string
	// The Amazon Resource Name (ARN) of the user pool to assign the tags to.
	ResourceArn *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.
	ResourceArn *string
	// The keys of the tags to remove from the user pool.
	TagKeys []*string
}

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

type UpdateAuthEventFeedbackInput struct {
	// The user pool ID.
	UserPoolId *string
	// The authentication event feedback value.
	FeedbackValue types.FeedbackValueType
	// The event ID.
	EventId *string
	// The feedback token.
	FeedbackToken *string
	// The user pool username.
	Username *string
}

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

type UpdateDeviceStatusInput struct {
	// The access token.
	AccessToken *string
	// The device key.
	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.
	GroupName *string
	// The user pool ID for the user pool.
	UserPoolId *string
	// The new precedence value for the group. For more information about this
	// parameter, see .
	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
	// A string containing the new description of the group.
	Description *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 {
	// A list of identity provider identifiers.
	IdpIdentifiers []*string
	// The identity provider name.
	ProviderName *string
	// The identity provider attribute mapping to be changed.
	AttributeMapping map[string]*string
	// The user pool ID.
	UserPoolId *string
	// The identity provider details to be updated, such as MetadataURL and
	// MetadataFile.
	ProviderDetails map[string]*string
}

type UpdateIdentityProviderOutput struct {
	// The identity provider object.
	IdentityProvider *types.IdentityProviderType

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

type UpdateResourceServerInput struct {
	// The identifier for the resource server.
	Identifier *string
	// The user pool ID for the user pool.
	UserPoolId *string
	// The name of the resource server.
	Name *string
	// The scope values to be set for the resource server.
	Scopes []*types.ResourceServerScopeType
}

type UpdateResourceServerOutput struct {
	// The resource server.
	ResourceServer *types.ResourceServerType

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

type UpdateUserAttributesInput struct {
	// 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
	// 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
	// The access token for the request to update user attributes.
	AccessToken *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 {
	// A list of provider names for the identity providers that are supported on this
	// client.
	SupportedIdentityProviders []*string
	// 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 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 ID of the client associated with the user pool.
	ClientId *string
	// A list of allowed logout URLs for the identity providers.
	LogoutURLs []*string
	// The time limit, in days, after which the refresh token is no longer valid and
	// cannot be used.
	RefreshTokenValidity *int32
	// 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.
	//
	// This
	// setting affects the behavior of following APIs:
	//
	//     * AdminInitiateAuth ()
	//
	//
	// * AdminRespondToAuthChallenge ()
	//
	//     * InitiateAuth ()
	//
	//     *
	// RespondToAuthChallenge ()
	//
	//     * ForgotPassword ()
	//
	//     * ConfirmForgotPassword
	// ()
	//
	//     * ConfirmSignUp ()
	//
	//     * ResendConfirmationCode ()
	//
	// 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 writeable attributes of the user pool.
	WriteAttributes []*string
	// The Amazon Pinpoint analytics configuration for collecting metrics for this user
	// pool. Cognito User Pools only supports sending events to Amazon Pinpoint
	// projects in the US East (N. Virginia) us-east-1 Region, regardless of the region
	// in which the user pool resides.
	AnalyticsConfiguration *types.AnalyticsConfigurationType
	// The user pool ID for the user pool where you want to update the user pool
	// client.
	UserPoolId *string
	// 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
	// The client name from the update user pool client request.
	ClientName *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
	// Set to true if the client is allowed to follow the OAuth protocol when
	// interacting with Cognito user pools.
	AllowedOAuthFlowsUserPoolClient *bool
	// 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 read-only attributes of the user pool.
	ReadAttributes []*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 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.
	Domain *string
	// 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.
	CustomDomainConfig *types.CustomDomainConfigType
	// The ID of the user pool that is associated with the custom domain that you are
	// updating the certificate for.
	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 {
	// Used to enable advanced security risk detection. Set the key
	// AdvancedSecurityMode to the value "AUDIT".
	UserPoolAddOns *types.UserPoolAddOnsType
	// A container with information about the SMS verification message.
	SmsVerificationMessage *string
	// Email configuration.
	EmailConfiguration *types.EmailConfigurationType
	// The subject of the email verification message.
	EmailVerificationSubject *string
	// The user pool ID for the user pool you want to update.
	UserPoolId *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
	// The contents of the email verification message.
	EmailVerificationMessage *string
	// Device configuration.
	DeviceConfiguration *types.DeviceConfigurationType
	// 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 attributes that are automatically verified when the Amazon Cognito service
	// makes a request to update user pools.
	AutoVerifiedAttributes []types.VerifiedAttributeType
	// The contents of the SMS authentication message.
	SmsAuthenticationMessage *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
	// A container with the policies you wish to update in a user pool.
	Policies *types.UserPoolPolicyType
	// The configuration for AdminCreateUser requests.
	AdminCreateUserConfig *types.AdminCreateUserConfigType
	// SMS configuration.
	SmsConfiguration *types.SmsConfigurationType
	// 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 friendly device name.
	FriendlyDeviceName *string
	// The session which should be passed both ways in challenge-response calls to the
	// service.
	Session *string
	// The one time password computed using the secret code returned by
	UserCode *string
	// The access token.
	AccessToken *string
}

type VerifySoftwareTokenOutput struct {
	// The status of the verify software token.
	Status types.VerifySoftwareTokenResponseType
	// The session which should be passed both ways in challenge-response calls to the
	// service.
	Session *string

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

type VerifyUserAttributeInput struct {
	// Represents the access token of the request to verify user attributes.
	AccessToken *string
	// The verification code in the request to verify user attributes.
	Code *string
	// The attribute name in the request to verify user attributes.
	AttributeName *string
}

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