types

package
v0.26.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 1, 2020 License: Apache-2.0 Imports: 3 Imported by: 66

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccountRecoverySettingType 

type AccountRecoverySettingType struct {

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

The data type for AccountRecoverySetting.

type AccountTakeoverActionType 

type AccountTakeoverActionType struct {

	// Flag specifying whether to send a notification.
	//
	// This member is required.
	Notify *bool

	// The event action.
	//
	//     * BLOCK Choosing this action will block the request.
	//
	//
	// * MFA_IF_CONFIGURED Throw MFA challenge if user has configured it, else allow
	// the request.
	//
	//     * MFA_REQUIRED Throw MFA challenge if user has configured it,
	// else block the request.
	//
	//     * NO_ACTION Allow the user sign-in.
	//
	// This member is required.
	EventAction AccountTakeoverEventActionType
}

Account takeover action type.

type AccountTakeoverActionsType 

type AccountTakeoverActionsType struct {

	// Action to take for a high risk.
	HighAction *AccountTakeoverActionType

	// Action to take for a medium risk.
	MediumAction *AccountTakeoverActionType

	// Action to take for a low risk.
	LowAction *AccountTakeoverActionType
}

Account takeover actions type.

type AccountTakeoverEventActionType 

type AccountTakeoverEventActionType string
const (
	AccountTakeoverEventActionTypeBlock             AccountTakeoverEventActionType = "BLOCK"
	AccountTakeoverEventActionTypeMfa_if_configured AccountTakeoverEventActionType = "MFA_IF_CONFIGURED"
	AccountTakeoverEventActionTypeMfa_required      AccountTakeoverEventActionType = "MFA_REQUIRED"
	AccountTakeoverEventActionTypeNo_action         AccountTakeoverEventActionType = "NO_ACTION"
)

Enum values for AccountTakeoverEventActionType

type AccountTakeoverRiskConfigurationType 

type AccountTakeoverRiskConfigurationType struct {

	// The notify configuration used to construct email notifications.
	NotifyConfiguration *NotifyConfigurationType

	// Account takeover risk configuration actions
	//
	// This member is required.
	Actions *AccountTakeoverActionsType
}

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

type AdminCreateUserConfigType 

type AdminCreateUserConfigType struct {

	// Set to True if only the administrator is allowed to create user profiles. Set to
	// False if users can sign themselves up via an app.
	AllowAdminCreateUserOnly *bool

	// The user account expiration limit, in days, after which the account is no longer
	// usable. To reset the account after that time limit, you must call
	// AdminCreateUser again, specifying "RESEND" for the MessageAction parameter. The
	// default value for this parameter is 7. If you set a value for
	// TemporaryPasswordValidityDays in PasswordPolicy, that value will be used and
	// UnusedAccountValidityDays will be deprecated for that user pool.
	UnusedAccountValidityDays *int32

	// The message template to be used for the welcome message to new users. See also
	// Customizing User Invitation Messages
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pool-settings-message-customizations.html#cognito-user-pool-settings-user-invitation-message-customization).
	InviteMessageTemplate *MessageTemplateType
}

The configuration for creating a new user profile.

type AdvancedSecurityModeType 

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

Enum values for AdvancedSecurityModeType

type AliasAttributeType 

type AliasAttributeType string
const (
	AliasAttributeTypePhone_number       AliasAttributeType = "phone_number"
	AliasAttributeTypeEmail              AliasAttributeType = "email"
	AliasAttributeTypePreferred_username AliasAttributeType = "preferred_username"
)

Enum values for AliasAttributeType

type AliasExistsException 

type AliasExistsException struct {
	Message *string
}

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

func (*AliasExistsException) Error 

func (e *AliasExistsException) Error() string

func (*AliasExistsException) ErrorCode 

func (e *AliasExistsException) ErrorCode() string

func (*AliasExistsException) ErrorFault 

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

func (*AliasExistsException) ErrorMessage 

func (e *AliasExistsException) ErrorMessage() string

type AnalyticsConfigurationType 

type AnalyticsConfigurationType struct {

	// If UserDataShared is true, Amazon Cognito will include user data in the events
	// it publishes to Amazon Pinpoint analytics.
	UserDataShared *bool

	// The ARN of an IAM role that authorizes Amazon Cognito to publish events to
	// Amazon Pinpoint analytics.
	//
	// This member is required.
	RoleArn *string

	// The external ID.
	//
	// This member is required.
	ExternalId *string

	// The application ID for an Amazon Pinpoint application.
	//
	// This member is required.
	ApplicationId *string
}

The Amazon Pinpoint analytics configuration for collecting metrics for a 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.

type AnalyticsMetadataType 

type AnalyticsMetadataType struct {

	// The endpoint ID.
	AnalyticsEndpointId *string
}

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

type AttributeDataType 

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

Enum values for AttributeDataType

type AttributeType 

type AttributeType struct {

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

	// The value of the attribute.
	Value *string
}

Specifies whether the attribute is standard or custom.

type AuthEventType 

type AuthEventType struct {

	// The event type.
	EventType EventType

	// The challenge responses.
	ChallengeResponses []*ChallengeResponseType

	// The event ID.
	EventId *string

	// The event response.
	EventResponse EventResponseType

	// The user context data captured at the time of an event request. It provides
	// additional information about the client from which event the request is
	// received.
	EventContextData *EventContextDataType

	// A flag specifying the user feedback captured at the time of an event request is
	// good or bad.
	EventFeedback *EventFeedbackType

	// The creation date
	CreationDate *time.Time

	// The event risk.
	EventRisk *EventRiskType
}

The authentication event type.

type AuthFlowType 

type AuthFlowType string
const (
	AuthFlowTypeUser_srp_auth            AuthFlowType = "USER_SRP_AUTH"
	AuthFlowTypeRefresh_token_auth       AuthFlowType = "REFRESH_TOKEN_AUTH"
	AuthFlowTypeRefresh_token            AuthFlowType = "REFRESH_TOKEN"
	AuthFlowTypeCustom_auth              AuthFlowType = "CUSTOM_AUTH"
	AuthFlowTypeAdmin_no_srp_auth        AuthFlowType = "ADMIN_NO_SRP_AUTH"
	AuthFlowTypeUser_password_auth       AuthFlowType = "USER_PASSWORD_AUTH"
	AuthFlowTypeAdmin_user_password_auth AuthFlowType = "ADMIN_USER_PASSWORD_AUTH"
)

Enum values for AuthFlowType

type AuthenticationResultType 

type AuthenticationResultType struct {

	// The token type.
	TokenType *string

	// The access token.
	AccessToken *string

	// The new device metadata from an authentication result.
	NewDeviceMetadata *NewDeviceMetadataType

	// The refresh token.
	RefreshToken *string

	// The ID token.
	IdToken *string

	// The expiration period of the authentication result in seconds.
	ExpiresIn *int32
}

The authentication result.

type ChallengeName 

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

Enum values for ChallengeName

type ChallengeNameType 

type ChallengeNameType string
const (
	ChallengeNameTypeSms_mfa                  ChallengeNameType = "SMS_MFA"
	ChallengeNameTypeSoftware_token_mfa       ChallengeNameType = "SOFTWARE_TOKEN_MFA"
	ChallengeNameTypeSelect_mfa_type          ChallengeNameType = "SELECT_MFA_TYPE"
	ChallengeNameTypeMfa_setup                ChallengeNameType = "MFA_SETUP"
	ChallengeNameTypePassword_verifier        ChallengeNameType = "PASSWORD_VERIFIER"
	ChallengeNameTypeCustom_challenge         ChallengeNameType = "CUSTOM_CHALLENGE"
	ChallengeNameTypeDevice_srp_auth          ChallengeNameType = "DEVICE_SRP_AUTH"
	ChallengeNameTypeDevice_password_verifier ChallengeNameType = "DEVICE_PASSWORD_VERIFIER"
	ChallengeNameTypeAdmin_no_srp_auth        ChallengeNameType = "ADMIN_NO_SRP_AUTH"
	ChallengeNameTypeNew_password_required    ChallengeNameType = "NEW_PASSWORD_REQUIRED"
)

Enum values for ChallengeNameType

type ChallengeResponse 

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

Enum values for ChallengeResponse

type ChallengeResponseType 

type ChallengeResponseType struct {

	// The challenge name
	ChallengeName ChallengeName

	// The challenge response.
	ChallengeResponse ChallengeResponse
}

The challenge response type.

type CodeDeliveryDetailsType 

type CodeDeliveryDetailsType struct {

	// The attribute name.
	AttributeName *string

	// The destination for the code delivery details.
	Destination *string

	// The delivery medium (email message or phone number).
	DeliveryMedium DeliveryMediumType
}

The code delivery details being returned from the server.

type CodeDeliveryFailureException 

type CodeDeliveryFailureException struct {
	Message *string
}

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

func (*CodeDeliveryFailureException) Error 

func (e *CodeDeliveryFailureException) Error() string

func (*CodeDeliveryFailureException) ErrorCode 

func (e *CodeDeliveryFailureException) ErrorCode() string

func (*CodeDeliveryFailureException) ErrorFault 

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

func (*CodeDeliveryFailureException) ErrorMessage 

func (e *CodeDeliveryFailureException) ErrorMessage() string

type CodeMismatchException 

type CodeMismatchException struct {
	Message *string
}

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

func (*CodeMismatchException) Error 

func (e *CodeMismatchException) Error() string

func (*CodeMismatchException) ErrorCode 

func (e *CodeMismatchException) ErrorCode() string

func (*CodeMismatchException) ErrorFault 

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

func (*CodeMismatchException) ErrorMessage 

func (e *CodeMismatchException) ErrorMessage() string

type CompromisedCredentialsActionsType 

type CompromisedCredentialsActionsType struct {

	// The event action.
	//
	// This member is required.
	EventAction CompromisedCredentialsEventActionType
}

The compromised credentials actions type

type CompromisedCredentialsEventActionType 

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

Enum values for CompromisedCredentialsEventActionType

type CompromisedCredentialsRiskConfigurationType 

type CompromisedCredentialsRiskConfigurationType struct {

	// Perform the action for these events. The default is to perform all events if no
	// event filter is specified.
	EventFilter []EventFilterType

	// The compromised credentials risk configuration actions.
	//
	// This member is required.
	Actions *CompromisedCredentialsActionsType
}

The compromised credentials risk configuration type.

type ConcurrentModificationException 

type ConcurrentModificationException struct {
	Message *string
}

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

func (*ConcurrentModificationException) Error 

func (e *ConcurrentModificationException) Error() string

func (*ConcurrentModificationException) ErrorCode 

func (e *ConcurrentModificationException) ErrorCode() string

func (*ConcurrentModificationException) ErrorFault 

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

func (*ConcurrentModificationException) ErrorMessage 

func (e *ConcurrentModificationException) ErrorMessage() string

type ContextDataType 

type ContextDataType struct {

	// HttpHeaders received on your server in same order.
	//
	// This member is required.
	HttpHeaders []*HttpHeader

	// Encoded data containing device fingerprinting details, collected using the
	// Amazon Cognito context data collection library.
	EncodedData *string

	// Source IP address of your user.
	//
	// This member is required.
	IpAddress *string

	// Your server endpoint where this API is invoked.
	//
	// This member is required.
	ServerName *string

	// Your server path where this API is invoked.
	//
	// This member is required.
	ServerPath *string
}

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

type CustomDomainConfigType 

type CustomDomainConfigType struct {

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

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

type DefaultEmailOptionType 

type DefaultEmailOptionType string
const (
	DefaultEmailOptionTypeConfirm_with_link DefaultEmailOptionType = "CONFIRM_WITH_LINK"
	DefaultEmailOptionTypeConfirm_with_code DefaultEmailOptionType = "CONFIRM_WITH_CODE"
)

Enum values for DefaultEmailOptionType

type DeliveryMediumType 

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

Enum values for DeliveryMediumType

type DeviceConfigurationType 

type DeviceConfigurationType struct {

	// If true, a device is only remembered on user prompt.
	DeviceOnlyRememberedOnUserPrompt *bool

	// Indicates whether a challenge is required on a new device. Only applicable to a
	// new device.
	ChallengeRequiredOnNewDevice *bool
}

The configuration for the user pool's device tracking.

type DeviceRememberedStatusType 

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

Enum values for DeviceRememberedStatusType

type DeviceSecretVerifierConfigType 

type DeviceSecretVerifierConfigType struct {

	// The password verifier.
	PasswordVerifier *string

	// The salt.
	Salt *string
}

The device verifier against which it will be authenticated.

type DeviceType 

type DeviceType struct {

	// The creation date of the device.
	DeviceCreateDate *time.Time

	// The date in which the device was last authenticated.
	DeviceLastAuthenticatedDate *time.Time

	// The device key.
	DeviceKey *string

	// The last modified date of the device.
	DeviceLastModifiedDate *time.Time

	// The device attributes.
	DeviceAttributes []*AttributeType
}

The device type.

type DomainDescriptionType 

type DomainDescriptionType struct {

	// The S3 bucket where the static files for this domain are stored.
	S3Bucket *string

	// The domain string.
	Domain *string

	// The AWS account ID for the user pool owner.
	AWSAccountId *string

	// The app version.
	Version *string

	// The ARN of the CloudFront distribution.
	CloudFrontDistribution *string

	// The user pool ID.
	UserPoolId *string

	// The domain status.
	Status DomainStatusType

	// The configuration for a custom domain that hosts the sign-up and sign-in
	// webpages for your application.
	CustomDomainConfig *CustomDomainConfigType
}

A container for information about a domain.

type DomainStatusType 

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

Enum values for DomainStatusType

type DuplicateProviderException 

type DuplicateProviderException struct {
	Message *string
}

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

func (*DuplicateProviderException) Error 

func (e *DuplicateProviderException) Error() string

func (*DuplicateProviderException) ErrorCode 

func (e *DuplicateProviderException) ErrorCode() string

func (*DuplicateProviderException) ErrorFault 

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

func (*DuplicateProviderException) ErrorMessage 

func (e *DuplicateProviderException) ErrorMessage() string

type EmailConfigurationType 

type EmailConfigurationType struct {

	// Identifies either the sender’s email address or the sender’s name with their
	// email address. For example, testuser@example.com or Test User . This address
	// will appear before the body of the email.
	From *string

	// Specifies whether Amazon Cognito emails your users by using its built-in email
	// functionality or your Amazon SES email configuration. Specify one of the
	// following values: COGNITO_DEFAULT When Amazon Cognito emails your users, it uses
	// its built-in email functionality. When you use the default option, Amazon
	// Cognito allows only a limited number of emails each day for your user pool. For
	// typical production environments, the default email limit is below the required
	// delivery volume. To achieve a higher delivery volume, specify DEVELOPER to use
	// your Amazon SES email configuration. To look up the email delivery limit for the
	// default option, see Limits in Amazon Cognito
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/limits.html) in the
	// Amazon Cognito Developer Guide. The default FROM address is
	// no-reply@verificationemail.com. To customize the FROM address, provide the ARN
	// of an Amazon SES verified email address for the SourceArn parameter. DEVELOPER
	// When Amazon Cognito emails your users, it uses your Amazon SES configuration.
	// Amazon Cognito calls Amazon SES on your behalf to send email from your verified
	// email address. When you use this option, the email delivery limits are the same
	// limits that apply to your Amazon SES verified email address in your AWS account.
	// If you use this option, you must provide the ARN of an Amazon SES verified email
	// address for the SourceArn parameter. Before Amazon Cognito can email your users,
	// it requires additional permissions to call Amazon SES on your behalf. When you
	// update your user pool with this option, Amazon Cognito creates a service-linked
	// role, which is a type of IAM role, in your AWS account. This role contains the
	// permissions that allow Amazon Cognito to access Amazon SES and send email
	// messages with your address. For more information about the service-linked role
	// that Amazon Cognito creates, see Using Service-Linked Roles for Amazon Cognito
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/using-service-linked-roles.html)
	// in the Amazon Cognito Developer Guide.
	EmailSendingAccount EmailSendingAccountType

	// The set of configuration rules that can be applied to emails sent using Amazon
	// SES. A configuration set is applied to an email by including a reference to the
	// configuration set in the headers of the email. Once applied, all of the rules in
	// that configuration set are applied to the email. Configuration sets can be used
	// to apply the following types of rules to emails:
	//
	//     * Event publishing –
	// Amazon SES can track the number of send, delivery, open, click, bounce, and
	// complaint events for each email sent. Use event publishing to send information
	// about these events to other AWS services such as SNS and CloudWatch.
	//
	//     * IP
	// pool management – When leasing dedicated IP addresses with Amazon SES, you can
	// create groups of IP addresses, called dedicated IP pools. You can then associate
	// the dedicated IP pools with configuration sets.
	ConfigurationSet *string

	// The destination to which the receiver of the email should reply to.
	ReplyToEmailAddress *string

	// The Amazon Resource Name (ARN) of a verified email address in Amazon SES. This
	// email address is used in one of the following ways, depending on the value that
	// you specify for the EmailSendingAccount parameter:
	//
	//     * If you specify
	// COGNITO_DEFAULT, Amazon Cognito uses this address as the custom FROM address
	// when it emails your users by using its built-in email account.
	//
	//     * If you
	// specify DEVELOPER, Amazon Cognito emails your users with this address by calling
	// Amazon SES on your behalf.
	SourceArn *string
}

The email configuration type.

type EmailSendingAccountType 

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

Enum values for EmailSendingAccountType

type EnableSoftwareTokenMFAException 

type EnableSoftwareTokenMFAException struct {
	Message *string
}

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

func (*EnableSoftwareTokenMFAException) Error 

func (e *EnableSoftwareTokenMFAException) Error() string

func (*EnableSoftwareTokenMFAException) ErrorCode 

func (e *EnableSoftwareTokenMFAException) ErrorCode() string

func (*EnableSoftwareTokenMFAException) ErrorFault 

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

func (*EnableSoftwareTokenMFAException) ErrorMessage 

func (e *EnableSoftwareTokenMFAException) ErrorMessage() string

type EventContextDataType 

type EventContextDataType struct {

	// The user's country.
	Country *string

	// The user's IP address.
	IpAddress *string

	// The user's city.
	City *string

	// The user's time zone.
	Timezone *string

	// The user's device name.
	DeviceName *string
}

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

type EventFeedbackType 

type EventFeedbackType struct {

	// The provider.
	//
	// This member is required.
	Provider *string

	// The event feedback date.
	FeedbackDate *time.Time

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

Specifies the event feedback type.

type EventFilterType 

type EventFilterType string
const (
	EventFilterTypeSign_in         EventFilterType = "SIGN_IN"
	EventFilterTypePassword_change EventFilterType = "PASSWORD_CHANGE"
	EventFilterTypeSign_up         EventFilterType = "SIGN_UP"
)

Enum values for EventFilterType

type EventResponseType 

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

Enum values for EventResponseType

type EventRiskType 

type EventRiskType struct {

	// The risk decision.
	RiskDecision RiskDecisionType

	// Indicates whether compromised credentials were detected during an authentication
	// event.
	CompromisedCredentialsDetected *bool

	// The risk level.
	RiskLevel RiskLevelType
}

The event risk type.

type EventType 

type EventType string
const (
	EventTypeSignin         EventType = "SignIn"
	EventTypeSignup         EventType = "SignUp"
	EventTypeForgotpassword EventType = "ForgotPassword"
)

Enum values for EventType

type ExpiredCodeException 

type ExpiredCodeException struct {
	Message *string
}

This exception is thrown if a code has expired.

func (*ExpiredCodeException) Error 

func (e *ExpiredCodeException) Error() string

func (*ExpiredCodeException) ErrorCode 

func (e *ExpiredCodeException) ErrorCode() string

func (*ExpiredCodeException) ErrorFault 

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

func (*ExpiredCodeException) ErrorMessage 

func (e *ExpiredCodeException) ErrorMessage() string

type ExplicitAuthFlowsType 

type ExplicitAuthFlowsType string
const (
	ExplicitAuthFlowsTypeAdmin_no_srp_auth              ExplicitAuthFlowsType = "ADMIN_NO_SRP_AUTH"
	ExplicitAuthFlowsTypeCustom_auth_flow_only          ExplicitAuthFlowsType = "CUSTOM_AUTH_FLOW_ONLY"
	ExplicitAuthFlowsTypeUser_password_auth             ExplicitAuthFlowsType = "USER_PASSWORD_AUTH"
	ExplicitAuthFlowsTypeAllow_admin_user_password_auth ExplicitAuthFlowsType = "ALLOW_ADMIN_USER_PASSWORD_AUTH"
	ExplicitAuthFlowsTypeAllow_custom_auth              ExplicitAuthFlowsType = "ALLOW_CUSTOM_AUTH"
	ExplicitAuthFlowsTypeAllow_user_password_auth       ExplicitAuthFlowsType = "ALLOW_USER_PASSWORD_AUTH"
	ExplicitAuthFlowsTypeAllow_user_srp_auth            ExplicitAuthFlowsType = "ALLOW_USER_SRP_AUTH"
	ExplicitAuthFlowsTypeAllow_refresh_token_auth       ExplicitAuthFlowsType = "ALLOW_REFRESH_TOKEN_AUTH"
)

Enum values for ExplicitAuthFlowsType

type FeedbackValueType 

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

Enum values for FeedbackValueType

type GroupExistsException 

type GroupExistsException struct {
	Message *string
}

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

func (*GroupExistsException) Error 

func (e *GroupExistsException) Error() string

func (*GroupExistsException) ErrorCode 

func (e *GroupExistsException) ErrorCode() string

func (*GroupExistsException) ErrorFault 

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

func (*GroupExistsException) ErrorMessage 

func (e *GroupExistsException) ErrorMessage() string

type GroupType 

type GroupType struct {

	// A nonnegative integer value that specifies the precedence of this group relative
	// to the other groups that a user can belong to in the user pool. If a user
	// belongs to two or more groups, it is the group with the highest precedence whose
	// role ARN will be used in the cognito:roles and cognito:preferred_role claims in
	// the user's tokens. Groups with higher Precedence values take precedence over
	// groups with lower Precedence values or with null Precedence values. Two groups
	// can have the same Precedence value. If this happens, neither group takes
	// precedence over the other. If two groups with the same Precedence have the same
	// role ARN, that role is used in the cognito:preferred_role claim in tokens for
	// users in each group. If the two groups have different role ARNs, the
	// cognito:preferred_role claim is not set in users' tokens. The default Precedence
	// value is null.
	Precedence *int32

	// The date the group was last modified.
	LastModifiedDate *time.Time

	// The date the group was created.
	CreationDate *time.Time

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

	// The name of the group.
	GroupName *string

	// The user pool ID for the user pool.
	UserPoolId *string

	// The role ARN for the group.
	RoleArn *string
}

The group type.

type HttpHeader 

type HttpHeader struct {

	// The header value.
	HeaderValue *string

	// The header name
	HeaderName *string
}

The HTTP header.

type IdentityProviderType 

type IdentityProviderType struct {

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

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

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

	// The user pool ID.
	UserPoolId *string

	// The date the identity provider was last modified.
	LastModifiedDate *time.Time

	// The date the identity provider was created.
	CreationDate *time.Time

	// The identity provider name.
	ProviderName *string

	// The identity provider type.
	ProviderType IdentityProviderTypeType
}

A container for information about an identity provider.

type IdentityProviderTypeType 

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

Enum values for IdentityProviderTypeType

type InternalErrorException 

type InternalErrorException struct {
	Message *string
}

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

func (*InternalErrorException) Error 

func (e *InternalErrorException) Error() string

func (*InternalErrorException) ErrorCode 

func (e *InternalErrorException) ErrorCode() string

func (*InternalErrorException) ErrorFault 

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

func (*InternalErrorException) ErrorMessage 

func (e *InternalErrorException) ErrorMessage() string

type InvalidEmailRoleAccessPolicyException 

type InvalidEmailRoleAccessPolicyException struct {
	Message *string
}

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

func (*InvalidEmailRoleAccessPolicyException) Error 

func (e *InvalidEmailRoleAccessPolicyException) Error() string

func (*InvalidEmailRoleAccessPolicyException) ErrorCode 

func (e *InvalidEmailRoleAccessPolicyException) ErrorCode() string

func (*InvalidEmailRoleAccessPolicyException) ErrorFault 

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

func (*InvalidEmailRoleAccessPolicyException) ErrorMessage 

func (e *InvalidEmailRoleAccessPolicyException) ErrorMessage() string

type InvalidLambdaResponseException 

type InvalidLambdaResponseException struct {
	Message *string
}

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

func (*InvalidLambdaResponseException) Error 

func (e *InvalidLambdaResponseException) Error() string

func (*InvalidLambdaResponseException) ErrorCode 

func (e *InvalidLambdaResponseException) ErrorCode() string

func (*InvalidLambdaResponseException) ErrorFault 

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

func (*InvalidLambdaResponseException) ErrorMessage 

func (e *InvalidLambdaResponseException) ErrorMessage() string

type InvalidOAuthFlowException 

type InvalidOAuthFlowException struct {
	Message *string
}

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

func (*InvalidOAuthFlowException) Error 

func (e *InvalidOAuthFlowException) Error() string

func (*InvalidOAuthFlowException) ErrorCode 

func (e *InvalidOAuthFlowException) ErrorCode() string

func (*InvalidOAuthFlowException) ErrorFault 

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

func (*InvalidOAuthFlowException) ErrorMessage 

func (e *InvalidOAuthFlowException) ErrorMessage() string

type InvalidParameterException 

type InvalidParameterException struct {
	Message *string
}

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

func (*InvalidParameterException) Error 

func (e *InvalidParameterException) Error() string

func (*InvalidParameterException) ErrorCode 

func (e *InvalidParameterException) ErrorCode() string

func (*InvalidParameterException) ErrorFault 

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

func (*InvalidParameterException) ErrorMessage 

func (e *InvalidParameterException) ErrorMessage() string

type InvalidPasswordException 

type InvalidPasswordException struct {
	Message *string
}

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

func (*InvalidPasswordException) Error 

func (e *InvalidPasswordException) Error() string

func (*InvalidPasswordException) ErrorCode 

func (e *InvalidPasswordException) ErrorCode() string

func (*InvalidPasswordException) ErrorFault 

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

func (*InvalidPasswordException) ErrorMessage 

func (e *InvalidPasswordException) ErrorMessage() string

type InvalidSmsRoleAccessPolicyException 

type InvalidSmsRoleAccessPolicyException struct {
	Message *string
}

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

func (*InvalidSmsRoleAccessPolicyException) Error 

func (e *InvalidSmsRoleAccessPolicyException) Error() string

func (*InvalidSmsRoleAccessPolicyException) ErrorCode 

func (e *InvalidSmsRoleAccessPolicyException) ErrorCode() string

func (*InvalidSmsRoleAccessPolicyException) ErrorFault 

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

func (*InvalidSmsRoleAccessPolicyException) ErrorMessage 

func (e *InvalidSmsRoleAccessPolicyException) ErrorMessage() string

type InvalidSmsRoleTrustRelationshipException 

type InvalidSmsRoleTrustRelationshipException struct {
	Message *string
}

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

func (*InvalidSmsRoleTrustRelationshipException) Error 

func (e *InvalidSmsRoleTrustRelationshipException) Error() string

func (*InvalidSmsRoleTrustRelationshipException) ErrorCode 

func (e *InvalidSmsRoleTrustRelationshipException) ErrorCode() string

func (*InvalidSmsRoleTrustRelationshipException) ErrorFault 

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

func (*InvalidSmsRoleTrustRelationshipException) ErrorMessage 

func (e *InvalidSmsRoleTrustRelationshipException) ErrorMessage() string

type InvalidUserPoolConfigurationException 

type InvalidUserPoolConfigurationException struct {
	Message *string
}

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

func (*InvalidUserPoolConfigurationException) Error 

func (e *InvalidUserPoolConfigurationException) Error() string

func (*InvalidUserPoolConfigurationException) ErrorCode 

func (e *InvalidUserPoolConfigurationException) ErrorCode() string

func (*InvalidUserPoolConfigurationException) ErrorFault 

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

func (*InvalidUserPoolConfigurationException) ErrorMessage 

func (e *InvalidUserPoolConfigurationException) ErrorMessage() string

type LambdaConfigType 

type LambdaConfigType struct {

	// A pre-registration AWS Lambda trigger.
	PreSignUp *string

	// A post-confirmation AWS Lambda trigger.
	PostConfirmation *string

	// Creates an authentication challenge.
	CreateAuthChallenge *string

	// A Lambda trigger that is invoked before token generation.
	PreTokenGeneration *string

	// A pre-authentication AWS Lambda trigger.
	PreAuthentication *string

	// The user migration Lambda config type.
	UserMigration *string

	// A custom Message AWS Lambda trigger.
	CustomMessage *string

	// A post-authentication AWS Lambda trigger.
	PostAuthentication *string

	// Verifies the authentication challenge response.
	VerifyAuthChallengeResponse *string

	// Defines the authentication challenge.
	DefineAuthChallenge *string
}

Specifies the configuration for AWS Lambda triggers.

type LimitExceededException 

type LimitExceededException struct {
	Message *string
}

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

func (*LimitExceededException) Error 

func (e *LimitExceededException) Error() string

func (*LimitExceededException) ErrorCode 

func (e *LimitExceededException) ErrorCode() string

func (*LimitExceededException) ErrorFault 

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

func (*LimitExceededException) ErrorMessage 

func (e *LimitExceededException) ErrorMessage() string

type MFAMethodNotFoundException 

type MFAMethodNotFoundException struct {
	Message *string
}

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

func (*MFAMethodNotFoundException) Error 

func (e *MFAMethodNotFoundException) Error() string

func (*MFAMethodNotFoundException) ErrorCode 

func (e *MFAMethodNotFoundException) ErrorCode() string

func (*MFAMethodNotFoundException) ErrorFault 

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

func (*MFAMethodNotFoundException) ErrorMessage 

func (e *MFAMethodNotFoundException) ErrorMessage() string

type MFAOptionType 

type MFAOptionType struct {

	// The delivery medium to send the MFA code. You can use this parameter to set only
	// the SMS delivery medium value.
	DeliveryMedium DeliveryMediumType

	// The attribute name of the MFA option type. The only valid value is phone_number.
	AttributeName *string
}

This data type is no longer supported. You can use it only for SMS MFA configurations. You can't use it for TOTP software token MFA configurations. To set either type of MFA configuration, use the AdminSetUserMFAPreference () or SetUserMFAPreference () actions. To look up information about either type of MFA configuration, use the AdminGetUserResponse$UserMFASettingList () or GetUserResponse$UserMFASettingList () responses.

type MessageActionType 

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

Enum values for MessageActionType

type MessageTemplateType 

type MessageTemplateType struct {

	// The message template for email messages.
	EmailMessage *string

	// The message template for SMS messages.
	SMSMessage *string

	// The subject line for email messages.
	EmailSubject *string
}

The message template structure.

type NewDeviceMetadataType 

type NewDeviceMetadataType struct {

	// The device group key.
	DeviceGroupKey *string

	// The device key.
	DeviceKey *string
}

The new device metadata type.

type NotAuthorizedException 

type NotAuthorizedException struct {
	Message *string
}

This exception is thrown when a user is not authorized.

func (*NotAuthorizedException) Error 

func (e *NotAuthorizedException) Error() string

func (*NotAuthorizedException) ErrorCode 

func (e *NotAuthorizedException) ErrorCode() string

func (*NotAuthorizedException) ErrorFault 

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

func (*NotAuthorizedException) ErrorMessage 

func (e *NotAuthorizedException) ErrorMessage() string

type NotifyConfigurationType 

type NotifyConfigurationType struct {

	// The email address that is sending the email. It must be either individually
	// verified with Amazon SES, or from a domain that has been verified with Amazon
	// SES.
	From *string

	// The Amazon Resource Name (ARN) of the identity that is associated with the
	// sending authorization policy. It permits Amazon Cognito to send for the email
	// address specified in the From parameter.
	//
	// This member is required.
	SourceArn *string

	// The email template used when a detected risk event is allowed.
	NoActionEmail *NotifyEmailType

	// The destination to which the receiver of an email should reply to.
	ReplyTo *string

	// The MFA email template used when MFA is challenged as part of a detected risk.
	MfaEmail *NotifyEmailType

	// Email template used when a detected risk event is blocked.
	BlockEmail *NotifyEmailType
}

The notify configuration type.

type NotifyEmailType 

type NotifyEmailType struct {

	// The subject.
	//
	// This member is required.
	Subject *string

	// The HTML body.
	HtmlBody *string

	// The text body.
	TextBody *string
}

The notify email type.

type NumberAttributeConstraintsType 

type NumberAttributeConstraintsType struct {

	// The minimum value of an attribute that is of the number data type.
	MinValue *string

	// The maximum value of an attribute that is of the number data type.
	MaxValue *string
}

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

type OAuthFlowType 

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

Enum values for OAuthFlowType

type PasswordPolicyType 

type PasswordPolicyType struct {

	// In the password policy that you have set, refers to whether you have required
	// users to use at least one symbol in their password.
	RequireSymbols *bool

	// In the password policy that you have set, refers to whether you have required
	// users to use at least one uppercase letter in their password.
	RequireUppercase *bool

	// In the password policy you have set, refers to the number of days a temporary
	// password is valid. If the user does not sign-in during this time, their password
	// will need to be reset by an administrator. When you set
	// TemporaryPasswordValidityDays for a user pool, you will no longer be able to set
	// the deprecated UnusedAccountValidityDays value for that user pool.
	TemporaryPasswordValidityDays *int32

	// The minimum length of the password policy that you have set. Cannot be less than
	// 6.
	MinimumLength *int32

	// In the password policy that you have set, refers to whether you have required
	// users to use at least one lowercase letter in their password.
	RequireLowercase *bool

	// In the password policy that you have set, refers to whether you have required
	// users to use at least one number in their password.
	RequireNumbers *bool
}

The password policy type.

type PasswordResetRequiredException 

type PasswordResetRequiredException struct {
	Message *string
}

This exception is thrown when a password reset is required.

func (*PasswordResetRequiredException) Error 

func (e *PasswordResetRequiredException) Error() string

func (*PasswordResetRequiredException) ErrorCode 

func (e *PasswordResetRequiredException) ErrorCode() string

func (*PasswordResetRequiredException) ErrorFault 

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

func (*PasswordResetRequiredException) ErrorMessage 

func (e *PasswordResetRequiredException) ErrorMessage() string

type PreconditionNotMetException 

type PreconditionNotMetException struct {
	Message *string
}

This exception is thrown when a precondition is not met.

func (*PreconditionNotMetException) Error 

func (e *PreconditionNotMetException) Error() string

func (*PreconditionNotMetException) ErrorCode 

func (e *PreconditionNotMetException) ErrorCode() string

func (*PreconditionNotMetException) ErrorFault 

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

func (*PreconditionNotMetException) ErrorMessage 

func (e *PreconditionNotMetException) ErrorMessage() string

type PreventUserExistenceErrorTypes 

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

Enum values for PreventUserExistenceErrorTypes

type ProviderDescription 

type ProviderDescription struct {

	// The identity provider name.
	ProviderName *string

	// The identity provider type.
	ProviderType IdentityProviderTypeType

	// The date the provider was added to the user pool.
	CreationDate *time.Time

	// The date the provider was last modified.
	LastModifiedDate *time.Time
}

A container for identity provider details.

type ProviderUserIdentifierType 

type ProviderUserIdentifierType struct {

	// The name of the provider, for example, Facebook, Google, or Login with Amazon.
	ProviderName *string

	// The name of the provider attribute to link to, for example, NameID.
	ProviderAttributeName *string

	// The value of the provider attribute to link to, for example, xxxxx_account.
	ProviderAttributeValue *string
}

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

type RecoveryOptionNameType 

type RecoveryOptionNameType string
const (
	RecoveryOptionNameTypeVerified_email        RecoveryOptionNameType = "verified_email"
	RecoveryOptionNameTypeVerified_phone_number RecoveryOptionNameType = "verified_phone_number"
	RecoveryOptionNameTypeAdmin_only            RecoveryOptionNameType = "admin_only"
)

Enum values for RecoveryOptionNameType

type RecoveryOptionType 

type RecoveryOptionType struct {

	// Specifies the recovery method for a user.
	//
	// This member is required.
	Name RecoveryOptionNameType

	// A positive integer specifying priority of a method with 1 being the highest
	// priority.
	//
	// This member is required.
	Priority *int32
}

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

type ResourceNotFoundException 

type ResourceNotFoundException struct {
	Message *string
}

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

func (*ResourceNotFoundException) Error 

func (e *ResourceNotFoundException) Error() string

func (*ResourceNotFoundException) ErrorCode 

func (e *ResourceNotFoundException) ErrorCode() string

func (*ResourceNotFoundException) ErrorFault 

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

func (*ResourceNotFoundException) ErrorMessage 

func (e *ResourceNotFoundException) ErrorMessage() string

type ResourceServerScopeType 

type ResourceServerScopeType struct {

	// The name of the scope.
	//
	// This member is required.
	ScopeName *string

	// A description of the scope.
	//
	// This member is required.
	ScopeDescription *string
}

A resource server scope.

type ResourceServerType 

type ResourceServerType struct {

	// The user pool ID for the user pool that hosts the resource server.
	UserPoolId *string

	// The identifier for the resource server.
	Identifier *string

	// A list of scopes that are defined for the resource server.
	Scopes []*ResourceServerScopeType

	// The name of the resource server.
	Name *string
}

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

type RiskConfigurationType 

type RiskConfigurationType struct {

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

	// The app client ID.
	ClientId *string

	// The account takeover risk configuration object including the NotifyConfiguration
	// object and Actions to take in the case of an account takeover.
	AccountTakeoverRiskConfiguration *AccountTakeoverRiskConfigurationType

	// The user pool ID.
	UserPoolId *string

	// The compromised credentials risk configuration object including the EventFilter
	// and the EventAction
	CompromisedCredentialsRiskConfiguration *CompromisedCredentialsRiskConfigurationType

	// The last modified date.
	LastModifiedDate *time.Time
}

The risk configuration type.

type RiskDecisionType 

type RiskDecisionType string
const (
	RiskDecisionTypeNorisk          RiskDecisionType = "NoRisk"
	RiskDecisionTypeAccounttakeover RiskDecisionType = "AccountTakeover"
	RiskDecisionTypeBlock           RiskDecisionType = "Block"
)

Enum values for RiskDecisionType

type RiskExceptionConfigurationType 

type RiskExceptionConfigurationType struct {

	// Overrides the risk decision to always block the pre-authentication requests. The
	// IP range is in CIDR notation: a compact representation of an IP address and its
	// associated routing prefix.
	BlockedIPRangeList []*string

	// Risk detection is not performed on the IP addresses in the range list. The IP
	// range is in CIDR notation.
	SkippedIPRangeList []*string
}

The type of the configuration to override the risk decision.

type RiskLevelType 

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

Enum values for RiskLevelType

type SMSMfaSettingsType 

type SMSMfaSettingsType struct {

	// Specifies whether SMS text message MFA is enabled.
	Enabled *bool

	// Specifies whether SMS is the preferred MFA method.
	PreferredMfa *bool
}

The type used for enabling SMS MFA at the user level.

type SchemaAttributeType 

type SchemaAttributeType struct {

	// Specifies whether a user pool attribute is required. If the attribute is
	// required and the user does not provide a value, registration or sign-in will
	// fail.
	Required *bool

	// Specifies the constraints for an attribute of the string type.
	StringAttributeConstraints *StringAttributeConstraintsType

	// A schema attribute of the name type.
	Name *string

	// We recommend that you use WriteAttributes
	// (https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_UserPoolClientType.html#CognitoUserPools-Type-UserPoolClientType-WriteAttributes)
	// in the user pool client to control how attributes can be mutated for new use
	// cases instead of using DeveloperOnlyAttribute. Specifies whether the attribute
	// type is developer only. This attribute can only be modified by an administrator.
	// Users will not be able to modify this attribute using their access token. For
	// example, DeveloperOnlyAttribute can be modified using the API but cannot be
	// updated using the API.
	DeveloperOnlyAttribute *bool

	// Specifies whether the value of the attribute can be changed. For any user pool
	// attribute that's mapped to an identity provider attribute, you must set this
	// parameter to true. Amazon Cognito updates mapped attributes when users sign in
	// to your application through an identity provider. If an attribute is immutable,
	// Amazon Cognito throws an error when it attempts to update the attribute. For
	// more information, see Specifying Identity Provider Attribute Mappings for Your
	// User Pool
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-specifying-attribute-mapping.html).
	Mutable *bool

	// Specifies the constraints for an attribute of the number type.
	NumberAttributeConstraints *NumberAttributeConstraintsType

	// The attribute data type.
	AttributeDataType AttributeDataType
}

Contains information about the schema attribute.

type ScopeDoesNotExistException 

type ScopeDoesNotExistException struct {
	Message *string
}

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

func (*ScopeDoesNotExistException) Error 

func (e *ScopeDoesNotExistException) Error() string

func (*ScopeDoesNotExistException) ErrorCode 

func (e *ScopeDoesNotExistException) ErrorCode() string

func (*ScopeDoesNotExistException) ErrorFault 

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

func (*ScopeDoesNotExistException) ErrorMessage 

func (e *ScopeDoesNotExistException) ErrorMessage() string

type SmsConfigurationType 

type SmsConfigurationType struct {

	// The external ID is a value that we recommend you use to add security to your IAM
	// role which is used to call Amazon SNS to send SMS messages for your user pool.
	// If you provide an ExternalId, the Cognito User Pool will include it when
	// attempting to assume your IAM role, so that you can set your roles trust policy
	// to require the ExternalID. If you use the Cognito Management Console to create a
	// role for SMS MFA, Cognito will create a role with the required permissions and a
	// trust policy that demonstrates use of the ExternalId.
	ExternalId *string

	// The Amazon Resource Name (ARN) of the Amazon Simple Notification Service (SNS)
	// caller. This is the ARN of the IAM role in your AWS account which Cognito will
	// use to send SMS messages.
	//
	// This member is required.
	SnsCallerArn *string
}

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

type SmsMfaConfigType 

type SmsMfaConfigType struct {

	// The SMS configuration.
	SmsConfiguration *SmsConfigurationType

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

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

type SoftwareTokenMFANotFoundException 

type SoftwareTokenMFANotFoundException struct {
	Message *string
}

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

func (*SoftwareTokenMFANotFoundException) Error 

func (e *SoftwareTokenMFANotFoundException) Error() string

func (*SoftwareTokenMFANotFoundException) ErrorCode 

func (e *SoftwareTokenMFANotFoundException) ErrorCode() string

func (*SoftwareTokenMFANotFoundException) ErrorFault 

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

func (*SoftwareTokenMFANotFoundException) ErrorMessage 

func (e *SoftwareTokenMFANotFoundException) ErrorMessage() string

type SoftwareTokenMfaConfigType 

type SoftwareTokenMfaConfigType struct {

	// Specifies whether software token MFA is enabled.
	Enabled *bool
}

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

type SoftwareTokenMfaSettingsType 

type SoftwareTokenMfaSettingsType struct {

	// Specifies whether software token MFA is the preferred MFA method.
	PreferredMfa *bool

	// Specifies whether software token MFA is enabled.
	Enabled *bool
}

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

type StatusType 

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

Enum values for StatusType

type StringAttributeConstraintsType 

type StringAttributeConstraintsType struct {

	// The minimum length.
	MinLength *string

	// The maximum length.
	MaxLength *string
}

The constraints associated with a string attribute.

type TooManyFailedAttemptsException 

type TooManyFailedAttemptsException struct {
	Message *string
}

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

func (*TooManyFailedAttemptsException) Error 

func (e *TooManyFailedAttemptsException) Error() string

func (*TooManyFailedAttemptsException) ErrorCode 

func (e *TooManyFailedAttemptsException) ErrorCode() string

func (*TooManyFailedAttemptsException) ErrorFault 

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

func (*TooManyFailedAttemptsException) ErrorMessage 

func (e *TooManyFailedAttemptsException) ErrorMessage() string

type TooManyRequestsException 

type TooManyRequestsException struct {
	Message *string
}

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

func (*TooManyRequestsException) Error 

func (e *TooManyRequestsException) Error() string

func (*TooManyRequestsException) ErrorCode 

func (e *TooManyRequestsException) ErrorCode() string

func (*TooManyRequestsException) ErrorFault 

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

func (*TooManyRequestsException) ErrorMessage 

func (e *TooManyRequestsException) ErrorMessage() string

type UICustomizationType 

type UICustomizationType struct {

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

	// The logo image for the UI customization.
	ImageUrl *string

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

	// The CSS version number.
	CSSVersion *string

	// The creation date for the UI customization.
	CreationDate *time.Time

	// The last-modified date for the UI customization.
	LastModifiedDate *time.Time

	// The user pool ID for the user pool.
	UserPoolId *string
}

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

type UnexpectedLambdaException 

type UnexpectedLambdaException struct {
	Message *string
}

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

func (*UnexpectedLambdaException) Error 

func (e *UnexpectedLambdaException) Error() string

func (*UnexpectedLambdaException) ErrorCode 

func (e *UnexpectedLambdaException) ErrorCode() string

func (*UnexpectedLambdaException) ErrorFault 

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

func (*UnexpectedLambdaException) ErrorMessage 

func (e *UnexpectedLambdaException) ErrorMessage() string

type UnsupportedIdentityProviderException 

type UnsupportedIdentityProviderException struct {
	Message *string
}

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

func (*UnsupportedIdentityProviderException) Error 

func (e *UnsupportedIdentityProviderException) Error() string

func (*UnsupportedIdentityProviderException) ErrorCode 

func (e *UnsupportedIdentityProviderException) ErrorCode() string

func (*UnsupportedIdentityProviderException) ErrorFault 

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

func (*UnsupportedIdentityProviderException) ErrorMessage 

func (e *UnsupportedIdentityProviderException) ErrorMessage() string

type UnsupportedUserStateException 

type UnsupportedUserStateException struct {
	Message *string
}

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

func (*UnsupportedUserStateException) Error 

func (e *UnsupportedUserStateException) Error() string

func (*UnsupportedUserStateException) ErrorCode 

func (e *UnsupportedUserStateException) ErrorCode() string

func (*UnsupportedUserStateException) ErrorFault 

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

func (*UnsupportedUserStateException) ErrorMessage 

func (e *UnsupportedUserStateException) ErrorMessage() string

type UserContextDataType 

type UserContextDataType struct {

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

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

type UserImportInProgressException 

type UserImportInProgressException struct {
	Message *string
}

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

func (*UserImportInProgressException) Error 

func (e *UserImportInProgressException) Error() string

func (*UserImportInProgressException) ErrorCode 

func (e *UserImportInProgressException) ErrorCode() string

func (*UserImportInProgressException) ErrorFault 

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

func (*UserImportInProgressException) ErrorMessage 

func (e *UserImportInProgressException) ErrorMessage() string

type UserImportJobStatusType 

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

Enum values for UserImportJobStatusType

type UserImportJobType 

type UserImportJobType struct {

	// The job ID for the user import job.
	JobId *string

	// The date when the user import job was completed.
	CompletionDate *time.Time

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

	// The message returned when the user import job is completed.
	CompletionMessage *string

	// The date when the user import job was started.
	StartDate *time.Time

	// The pre-signed URL to be used to upload the .csv file.
	PreSignedUrl *string

	// The number of users that were successfully imported.
	ImportedUsers *int64

	// The job name for the user import job.
	JobName *string

	// The date the user import job was created.
	CreationDate *time.Time

	// The number of users that could not be imported.
	FailedUsers *int64

	// The status of the user import job. One of the following:
	//
	//     * Created - The
	// job was created but not started.
	//
	//     * Pending - A transition state. You have
	// started the job, but it has not begun importing users yet.
	//
	//     * InProgress -
	// The job has started, and users are being imported.
	//
	//     * Stopping - You have
	// stopped the job, but the job has not stopped importing users yet.
	//
	//     * Stopped
	// - You have stopped the job, and the job has stopped importing users.
	//
	//     *
	// Succeeded - The job has completed successfully.
	//
	//     * Failed - The job has
	// stopped due to an error.
	//
	//     * Expired - You created a job, but did not start
	// the job within 24-48 hours. All data associated with the job was deleted, and
	// the job cannot be started.
	Status UserImportJobStatusType

	// The role ARN for the Amazon CloudWatch Logging role for the user import job. For
	// more information, see "Creating the CloudWatch Logs IAM Role" in the Amazon
	// Cognito Developer Guide.
	CloudWatchLogsRoleArn *string

	// The number of users that were skipped.
	SkippedUsers *int64
}

The user import job type.

type UserLambdaValidationException 

type UserLambdaValidationException struct {
	Message *string
}

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

func (*UserLambdaValidationException) Error 

func (e *UserLambdaValidationException) Error() string

func (*UserLambdaValidationException) ErrorCode 

func (e *UserLambdaValidationException) ErrorCode() string

func (*UserLambdaValidationException) ErrorFault 

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

func (*UserLambdaValidationException) ErrorMessage 

func (e *UserLambdaValidationException) ErrorMessage() string

type UserNotConfirmedException 

type UserNotConfirmedException struct {
	Message *string
}

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

func (*UserNotConfirmedException) Error 

func (e *UserNotConfirmedException) Error() string

func (*UserNotConfirmedException) ErrorCode 

func (e *UserNotConfirmedException) ErrorCode() string

func (*UserNotConfirmedException) ErrorFault 

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

func (*UserNotConfirmedException) ErrorMessage 

func (e *UserNotConfirmedException) ErrorMessage() string

type UserNotFoundException 

type UserNotFoundException struct {
	Message *string
}

This exception is thrown when a user is not found.

func (*UserNotFoundException) Error 

func (e *UserNotFoundException) Error() string

func (*UserNotFoundException) ErrorCode 

func (e *UserNotFoundException) ErrorCode() string

func (*UserNotFoundException) ErrorFault 

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

func (*UserNotFoundException) ErrorMessage 

func (e *UserNotFoundException) ErrorMessage() string

type UserPoolAddOnNotEnabledException 

type UserPoolAddOnNotEnabledException struct {
	Message *string
}

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

func (*UserPoolAddOnNotEnabledException) Error 

func (e *UserPoolAddOnNotEnabledException) Error() string

func (*UserPoolAddOnNotEnabledException) ErrorCode 

func (e *UserPoolAddOnNotEnabledException) ErrorCode() string

func (*UserPoolAddOnNotEnabledException) ErrorFault 

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

func (*UserPoolAddOnNotEnabledException) ErrorMessage 

func (e *UserPoolAddOnNotEnabledException) ErrorMessage() string

type UserPoolAddOnsType 

type UserPoolAddOnsType struct {

	// The advanced security mode.
	//
	// This member is required.
	AdvancedSecurityMode AdvancedSecurityModeType
}

The user pool add-ons type.

type UserPoolClientDescription 

type UserPoolClientDescription struct {

	// The ID of the client associated with the user pool.
	ClientId *string

	// The client name from the user pool client description.
	ClientName *string

	// The user pool ID for the user pool where you want to describe the user pool
	// client.
	UserPoolId *string
}

The description of the user pool client.

type UserPoolClientType 

type UserPoolClientType struct {

	// The authentication flows that are supported by the user pool clients. Flow names
	// without the ALLOW_ prefix are deprecated in favor of new names with the ALLOW_
	// prefix. Note that values with ALLOW_ prefix cannot be used along with values
	// without ALLOW_ prefix. Valid values include:
	//
	//     *
	// ALLOW_ADMIN_USER_PASSWORD_AUTH: Enable admin based user password authentication
	// flow ADMIN_USER_PASSWORD_AUTH. This setting replaces the ADMIN_NO_SRP_AUTH
	// setting. With this authentication flow, Cognito receives the password in the
	// request instead of using the SRP (Secure Remote Password protocol) protocol to
	// verify passwords.
	//
	//     * ALLOW_CUSTOM_AUTH: Enable Lambda trigger based
	// authentication.
	//
	//     * ALLOW_USER_PASSWORD_AUTH: Enable user password-based
	// authentication. In this flow, Cognito receives the password in the request
	// instead of using the SRP protocol to verify passwords.
	//
	//     *
	// ALLOW_USER_SRP_AUTH: Enable SRP based authentication.
	//
	//     *
	// ALLOW_REFRESH_TOKEN_AUTH: Enable authflow to refresh tokens.
	ExplicitAuthFlows []ExplicitAuthFlowsType

	// The 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 writeable attributes.
	WriteAttributes []*string

	// The time limit, in days, after which the refresh token is no longer valid and
	// cannot be used.
	RefreshTokenValidity *int32

	// Set to true if the client is allowed to follow the OAuth protocol when
	// interacting with Cognito user pools.
	AllowedOAuthFlowsUserPoolClient *bool

	// The Read-only attributes.
	ReadAttributes []*string

	// The Amazon Pinpoint analytics configuration for the user pool client. Cognito
	// User Pools only supports sending events to Amazon Pinpoint projects in the US
	// East (N. Virginia) us-east-1 Region, regardless of the region in which the user
	// pool resides.
	AnalyticsConfiguration *AnalyticsConfigurationType

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

	// The client secret from the user pool request of the client type.
	ClientSecret *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

	// A list of provider names for the identity providers that are supported on this
	// client.
	SupportedIdentityProviders []*string

	// The client name from the user pool request of the client type.
	ClientName *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 []OAuthFlowType

	// The user pool ID for the user pool client.
	UserPoolId *string

	// The date the user pool client was created.
	CreationDate *time.Time

	// The date the user pool client was last modified.
	LastModifiedDate *time.Time

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

Contains information about a user pool client.

type UserPoolDescriptionType 

type UserPoolDescriptionType struct {

	// The name in a user pool description.
	Name *string

	// The date the user pool description was last modified.
	LastModifiedDate *time.Time

	// The date the user pool description was created.
	CreationDate *time.Time

	// The ID in a user pool description.
	Id *string

	// The AWS Lambda configuration information in a user pool description.
	LambdaConfig *LambdaConfigType

	// The user pool status in a user pool description.
	Status StatusType
}

A user pool description.

type UserPoolMfaType 

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

Enum values for UserPoolMfaType

type UserPoolPolicyType 

type UserPoolPolicyType struct {

	// The password policy.
	PasswordPolicy *PasswordPolicyType
}

The policy associated with a user pool.

type UserPoolTaggingException 

type UserPoolTaggingException struct {
	Message *string
}

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

func (*UserPoolTaggingException) Error 

func (e *UserPoolTaggingException) Error() string

func (*UserPoolTaggingException) ErrorCode 

func (e *UserPoolTaggingException) ErrorCode() string

func (*UserPoolTaggingException) ErrorFault 

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

func (*UserPoolTaggingException) ErrorMessage 

func (e *UserPoolTaggingException) ErrorMessage() string

type UserPoolType 

type UserPoolType struct {

	// The contents of the SMS verification message.
	SmsVerificationMessage *string

	// The SMS configuration.
	SmsConfiguration *SmsConfigurationType

	// A number estimating the size of the user pool.
	EstimatedNumberOfUsers *int32

	// The AWS Lambda triggers associated with the user pool.
	LambdaConfig *LambdaConfigType

	// Holds the domain prefix if the user pool has a domain associated with it.
	Domain *string

	// Specifies the attributes that are aliased in a user pool.
	AliasAttributes []AliasAttributeType

	// The name of the user pool.
	Name *string

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

	// The date the user pool was created.
	CreationDate *time.Time

	// The template for verification messages.
	VerificationMessageTemplate *VerificationMessageTemplateType

	// Use this setting to define which verified available method a user can use to
	// recover their password when they call ForgotPassword. It allows you to define a
	// preferred method when a user has more than one method available. With this
	// setting, SMS does not qualify for a valid password recovery mechanism if the
	// user also has SMS MFA enabled. In the absence of this setting, Cognito uses the
	// legacy behavior to determine the recovery method where SMS is preferred over
	// email.
	AccountRecoverySetting *AccountRecoverySettingType

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

	// The configuration for AdminCreateUser requests.
	AdminCreateUserConfig *AdminCreateUserConfigType

	// The reason why the SMS configuration cannot send the messages to your users.
	SmsConfigurationFailure *string

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

	// The email configuration.
	EmailConfiguration *EmailConfigurationType

	// You can choose to enable case sensitivity on the username input for the selected
	// sign-in option. For example, when this is set to False, users will be able to
	// sign in using either "username" or "Username". This configuration is immutable
	// once it has been set. For more information, see .
	UsernameConfiguration *UsernameConfigurationType

	// A custom domain name that you provide to Amazon Cognito. This parameter applies
	// only if you use a custom domain to host the sign-up and sign-in pages for your
	// application. For example: auth.example.com. For more information about adding a
	// custom domain to your user pool, see Using Your Own Domain for the Hosted UI
	// (https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-add-custom-domain.html).
	CustomDomain *string

	// A container with the schema attributes of a user pool.
	SchemaAttributes []*SchemaAttributeType

	// Can be one of the following values:
	//
	//     * OFF - MFA tokens are not required and
	// cannot be specified during user registration.
	//
	//     * ON - MFA tokens are
	// required for all user registrations. You can only specify required when you are
	// initially creating a user pool.
	//
	//     * OPTIONAL - Users have the option when
	// registering to create an MFA token.
	MfaConfiguration UserPoolMfaType

	// The tags that are assigned to the user pool. A tag is a label that you can apply
	// to user pools to categorize and manage them in different ways, such as by
	// purpose, owner, environment, or other criteria.
	UserPoolTags map[string]*string

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

	// The Amazon Resource Name (ARN) for the user pool.
	Arn *string

	// The ID of the user pool.
	Id *string

	// The device configuration.
	DeviceConfiguration *DeviceConfigurationType

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

	// Specifies whether email addresses or phone numbers can be specified as usernames
	// when a user signs up.
	UsernameAttributes []UsernameAttributeType

	// The reason why the email configuration cannot send the messages to your users.
	EmailConfigurationFailure *string

	// Specifies the attributes that are auto-verified in a user pool.
	AutoVerifiedAttributes []VerifiedAttributeType

	// The user pool add-ons.
	UserPoolAddOns *UserPoolAddOnsType

	// The status of a user pool.
	Status StatusType
}

A container for information about the user pool.

type UserStatusType 

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

Enum values for UserStatusType

type UserType 

type UserType struct {

	// The user status. Can be one of the following:
	//
	//     * UNCONFIRMED - User has been
	// created but not confirmed.
	//
	//     * CONFIRMED - User has been confirmed.
	//
	//     *
	// ARCHIVED - User is no longer active.
	//
	//     * COMPROMISED - User is disabled due
	// to a potential security threat.
	//
	//     * UNKNOWN - User status is not known.
	//
	//
	// * RESET_REQUIRED - User is confirmed, but the user must request a code and reset
	// his or her password before he or she can sign in.
	//
	//     * FORCE_CHANGE_PASSWORD -
	// The user is confirmed and the user can sign in using a temporary password, but
	// on first sign-in, the user must change his or her password to a new value before
	// doing anything else.
	UserStatus UserStatusType

	// The user name of the user you wish to describe.
	Username *string

	// The creation date of the user.
	UserCreateDate *time.Time

	// Specifies whether the user is enabled.
	Enabled *bool

	// A container with information about the user type attributes.
	Attributes []*AttributeType

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

	// The MFA options for the user.
	MFAOptions []*MFAOptionType
}

The user type.

type UsernameAttributeType 

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

Enum values for UsernameAttributeType

type UsernameConfigurationType 

type UsernameConfigurationType struct {

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

The username configuration type.

type UsernameExistsException 

type UsernameExistsException struct {
	Message *string
}

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

func (*UsernameExistsException) Error 

func (e *UsernameExistsException) Error() string

func (*UsernameExistsException) ErrorCode 

func (e *UsernameExistsException) ErrorCode() string

func (*UsernameExistsException) ErrorFault 

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

func (*UsernameExistsException) ErrorMessage 

func (e *UsernameExistsException) ErrorMessage() string

type VerificationMessageTemplateType 

type VerificationMessageTemplateType struct {

	// The email message template.
	EmailMessage *string

	// The subject line for the email message template for sending a confirmation link
	// to the user.
	EmailSubjectByLink *string

	// The SMS message template.
	SmsMessage *string

	// The email message template for sending a confirmation link to the user.
	EmailMessageByLink *string

	// The default email option.
	DefaultEmailOption DefaultEmailOptionType

	// The subject line for the email message template.
	EmailSubject *string
}

The template for verification messages.

type VerifiedAttributeType 

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

Enum values for VerifiedAttributeType

type VerifySoftwareTokenResponseType 

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

Enum values for VerifySoftwareTokenResponseType

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.