Module aws_sdk_cognitoidentityprovider::types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that Amazon Cognito Identity Provider can respond with.

Structs

• AccountRecoverySettingType

  The data type for AccountRecoverySetting.

• AccountTakeoverActionType

  Account takeover action type.

• AccountTakeoverActionsType

  Account takeover actions type.

• AccountTakeoverRiskConfigurationType

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

• AdminCreateUserConfigType

  The configuration for creating a new user profile.

• AnalyticsConfigurationType

  The Amazon Pinpoint analytics configuration necessary to collect metrics for a user pool.

• AnalyticsMetadataType

  An Amazon Pinpoint analytics endpoint.

• AttributeType

  Specifies whether the attribute is standard or custom.

• AuthEventType

  The authentication event type.

• AuthenticationResultType

  The authentication result.

• ChallengeResponseType

  The challenge response type.

• CloudWatchLogsConfigurationType

  The CloudWatch logging destination of a user pool detailed activity logging configuration.

• CodeDeliveryDetailsType

  The delivery details for an email or SMS message that Amazon Cognito sent for authentication or verification.

• CompromisedCredentialsActionsType

  The compromised credentials actions type.

• CompromisedCredentialsRiskConfigurationType

  The compromised credentials risk configuration type.

• ContextDataType

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

• CustomDomainConfigType

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

• CustomEmailLambdaVersionConfigType

  The properties of a custom email sender Lambda trigger.

• CustomSmsLambdaVersionConfigType

  The properties of a custom SMS sender Lambda trigger.

• DeviceConfigurationType

  The device-remembering configuration for a user pool. A DescribeUserPool request returns a null value for this object when the user pool isn't configured to remember devices. When device remembering is active, you can remember a user's device with a ConfirmDevice API request. Additionally. when the property DeviceOnlyRememberedOnUserPrompt is true, you must follow ConfirmDevice with an UpdateDeviceStatus API request that sets the user's device to remembered or not_remembered.

• DeviceSecretVerifierConfigType

  The device verifier against which it is authenticated.

• DeviceType

  The device type.

• DomainDescriptionType

  A container for information about a domain.

• EmailConfigurationType

  The email configuration of your user pool. The email configuration type sets your preferred sending method, Amazon Web Services Region, and sender for messages from your user pool.

• EventContextDataType

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

• EventFeedbackType

  Specifies the event feedback type.

• EventRiskType

  The event risk type.

• GroupType

  The group type.

• HttpHeader

  The HTTP header.

• IdentityProviderType

  A container for information about an IdP.

• LambdaConfigType

  Specifies the configuration for Lambda triggers.

• LogConfigurationType

  The logging parameters of a user pool.

• LogDeliveryConfigurationType

  The logging parameters of a user pool.

• MessageTemplateType

  The message template structure.

• MfaOptionType

  This data type is no longer supported. Applies only to SMS multi-factor authentication (MFA) configurations. Does not apply to time-based one-time password (TOTP) software token MFA configurations.

• NewDeviceMetadataType

  The new device metadata type.

• NotifyConfigurationType

  The notify configuration type.

• NotifyEmailType

  The notify email type.

• NumberAttributeConstraintsType

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

• PasswordPolicyType

  The password policy type.

• PreTokenGenerationVersionConfigType

  The properties of a pre token generation Lambda trigger.

• ProviderDescription

  A container for IdP details.

• ProviderUserIdentifierType

  A container for information about an IdP for a user pool.

• RecoveryOptionType

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

• ResourceServerScopeType

  A resource server scope.

• ResourceServerType

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

• RiskConfigurationType

  The risk configuration type.

• RiskExceptionConfigurationType

  The type of the configuration to override the risk decision.

• SchemaAttributeType

  A list of the user attributes and their properties in your user pool. The attribute schema contains standard attributes, custom attributes with a custom: prefix, and developer attributes with a dev: prefix. For more information, see User pool attributes.

• SmsConfigurationType

  The SMS configuration type is the settings that your Amazon Cognito user pool must use to send an SMS message from your Amazon Web Services account through Amazon Simple Notification Service. To send SMS messages with Amazon SNS in the Amazon Web Services Region that you want, the Amazon Cognito user pool uses an Identity and Access Management (IAM) role in your Amazon Web Services account.

• SmsMfaConfigType

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

• SmsMfaSettingsType

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

• SoftwareTokenMfaConfigType

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

• SoftwareTokenMfaSettingsType

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

• StringAttributeConstraintsType

  The constraints associated with a string attribute.

• TokenValidityUnitsType

  The data type TokenValidityUnits specifies the time units you use when you set the duration of ID, access, and refresh tokens.

• UiCustomizationType

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

• UserAttributeUpdateSettingsType

  The settings for updates to user attributes. These settings include the property AttributesRequireVerificationBeforeUpdate, a user-pool setting that tells Amazon Cognito how to handle changes to the value of your users' email address and phone number attributes. For more information, see Verifying updates to email addresses and phone numbers.

• UserContextDataType

  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.

• UserImportJobType

  The user import job type.

• UserPoolAddOnsType

  User pool add-ons. Contains settings for activation of advanced security features. To log user security information but take no action, set to AUDIT. To configure automatic security responses to risky traffic to your user pool, set to ENFORCED.

• UserPoolClientDescription

  The description of the user pool client.

• UserPoolClientType

  Contains information about a user pool client.

• UserPoolDescriptionType

  A user pool description.

• UserPoolPolicyType

  The policy associated with a user pool.

• UserPoolType

  A container for information about the user pool.

• UserType

  A user profile in a Amazon Cognito user pool.

• UsernameConfigurationType

  The username configuration type.

• VerificationMessageTemplateType

  The template for verification messages.

Enums

• AccountTakeoverEventActionType
  When writing a match expression against AccountTakeoverEventActionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AdvancedSecurityModeType
  When writing a match expression against AdvancedSecurityModeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AliasAttributeType
  When writing a match expression against AliasAttributeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AttributeDataType
  When writing a match expression against AttributeDataType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AuthFlowType
  When writing a match expression against AuthFlowType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ChallengeName
  When writing a match expression against ChallengeName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ChallengeNameType
  When writing a match expression against ChallengeNameType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ChallengeResponse
  When writing a match expression against ChallengeResponse, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• CompromisedCredentialsEventActionType
  When writing a match expression against CompromisedCredentialsEventActionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• CustomEmailSenderLambdaVersionType
  When writing a match expression against CustomEmailSenderLambdaVersionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• CustomSmsSenderLambdaVersionType
  When writing a match expression against CustomSmsSenderLambdaVersionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DefaultEmailOptionType
  When writing a match expression against DefaultEmailOptionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DeletionProtectionType
  When writing a match expression against DeletionProtectionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DeliveryMediumType
  When writing a match expression against DeliveryMediumType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DeviceRememberedStatusType
  When writing a match expression against DeviceRememberedStatusType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DomainStatusType
  When writing a match expression against DomainStatusType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• EmailSendingAccountType
  When writing a match expression against EmailSendingAccountType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• EventFilterType
  When writing a match expression against EventFilterType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• EventResponseType
  When writing a match expression against EventResponseType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• EventSourceName
  When writing a match expression against EventSourceName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• EventType
  When writing a match expression against EventType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ExplicitAuthFlowsType
  When writing a match expression against ExplicitAuthFlowsType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• FeedbackValueType
  When writing a match expression against FeedbackValueType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• IdentityProviderTypeType
  When writing a match expression against IdentityProviderTypeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• LogLevel
  When writing a match expression against LogLevel, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• MessageActionType
  When writing a match expression against MessageActionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• OAuthFlowType
  When writing a match expression against OAuthFlowType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• PreTokenGenerationLambdaVersionType
  When writing a match expression against PreTokenGenerationLambdaVersionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• PreventUserExistenceErrorTypes
  When writing a match expression against PreventUserExistenceErrorTypes, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RecoveryOptionNameType
  When writing a match expression against RecoveryOptionNameType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RiskDecisionType
  When writing a match expression against RiskDecisionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• RiskLevelType
  When writing a match expression against RiskLevelType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• StatusType
  When writing a match expression against StatusType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• TimeUnitsType
  When writing a match expression against TimeUnitsType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• UserImportJobStatusType
  When writing a match expression against UserImportJobStatusType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• UserPoolMfaType
  When writing a match expression against UserPoolMfaType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• UserStatusType
  When writing a match expression against UserStatusType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• UsernameAttributeType
  When writing a match expression against UsernameAttributeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• VerifiedAttributeType
  When writing a match expression against VerifiedAttributeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• VerifySoftwareTokenResponseType
  When writing a match expression against VerifySoftwareTokenResponseType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.