@aws-sdk/client-cognito-identity-provider 3.32.0 → 3.36.0

package/dist-types/models/models_1.d.ts

@@ -0,0 +1,861 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+import { AccountRecoverySettingType, AdminCreateUserConfigType, AnalyticsConfigurationType, AttributeType, CodeDeliveryDetailsType, CustomDomainConfigType, DeviceConfigurationType, DeviceRememberedStatusType, EmailConfigurationType, ExplicitAuthFlowsType, FeedbackValueType, GroupType, IdentityProviderType, LambdaConfigType, OAuthFlowType, PreventUserExistenceErrorTypes, ResourceServerScopeType, ResourceServerType, SmsConfigurationType, TokenValidityUnitsType, UserImportJobType, UserPoolAddOnsType, UserPoolClientType, UserPoolMfaType, UserPoolPolicyType, VerificationMessageTemplateType, VerifiedAttributeType } from "./models_0";
+/**
+ * <p>Represents the response from the server to the request to start the user import
+ *             job.</p>
+ */
+export interface StartUserImportJobResponse {
+    /**
+     * <p>The job object that represents the user import job.</p>
+     */
+    UserImportJob?: UserImportJobType;
+}
+export declare namespace StartUserImportJobResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StartUserImportJobResponse) => any;
+}
+/**
+ * <p>Represents the request to stop the user import job.</p>
+ */
+export interface StopUserImportJobRequest {
+    /**
+     * <p>The user pool ID for the user pool that the users are being imported into.</p>
+     */
+    UserPoolId: string | undefined;
+    /**
+     * <p>The job ID for the user import job.</p>
+     */
+    JobId: string | undefined;
+}
+export declare namespace StopUserImportJobRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StopUserImportJobRequest) => any;
+}
+/**
+ * <p>Represents the response from the server to the request to stop the user import
+ *             job.</p>
+ */
+export interface StopUserImportJobResponse {
+    /**
+     * <p>The job object that represents the user import job.</p>
+     */
+    UserImportJob?: UserImportJobType;
+}
+export declare namespace StopUserImportJobResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: StopUserImportJobResponse) => any;
+}
+export interface TagResourceRequest {
+    /**
+     * <p>The Amazon Resource Name (ARN) of the user pool to assign the tags to.</p>
+     */
+    ResourceArn: string | undefined;
+    /**
+     * <p>The tags to assign to the user pool.</p>
+     */
+    Tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    /**
+     * <p>The Amazon Resource Name (ARN) of the user pool that the tags are assigned to.</p>
+     */
+    ResourceArn: string | undefined;
+    /**
+     * <p>The keys of the tags to remove from the user pool.</p>
+     */
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateAuthEventFeedbackRequest {
+    /**
+     * <p>The user pool ID.</p>
+     */
+    UserPoolId: string | undefined;
+    /**
+     * <p>The user pool username.</p>
+     */
+    Username: string | undefined;
+    /**
+     * <p>The event ID.</p>
+     */
+    EventId: string | undefined;
+    /**
+     * <p>The feedback token.</p>
+     */
+    FeedbackToken: string | undefined;
+    /**
+     * <p>The authentication event feedback value.</p>
+     */
+    FeedbackValue: FeedbackValueType | string | undefined;
+}
+export declare namespace UpdateAuthEventFeedbackRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateAuthEventFeedbackRequest) => any;
+}
+export interface UpdateAuthEventFeedbackResponse {
+}
+export declare namespace UpdateAuthEventFeedbackResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateAuthEventFeedbackResponse) => any;
+}
+/**
+ * <p>Represents the request to update the device status.</p>
+ */
+export interface UpdateDeviceStatusRequest {
+    /**
+     * <p>The access token.</p>
+     */
+    AccessToken: string | undefined;
+    /**
+     * <p>The device key.</p>
+     */
+    DeviceKey: string | undefined;
+    /**
+     * <p>The status of whether a device is remembered.</p>
+     */
+    DeviceRememberedStatus?: DeviceRememberedStatusType | string;
+}
+export declare namespace UpdateDeviceStatusRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateDeviceStatusRequest) => any;
+}
+/**
+ * <p>The response to the request to update the device status.</p>
+ */
+export interface UpdateDeviceStatusResponse {
+}
+export declare namespace UpdateDeviceStatusResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateDeviceStatusResponse) => any;
+}
+export interface UpdateGroupRequest {
+    /**
+     * <p>The name of the group.</p>
+     */
+    GroupName: string | undefined;
+    /**
+     * <p>The user pool ID for the user pool.</p>
+     */
+    UserPoolId: string | undefined;
+    /**
+     * <p>A string containing the new description of the group.</p>
+     */
+    Description?: string;
+    /**
+     * <p>The new role ARN for the group. This is used for setting the
+     *                 <code>cognito:roles</code> and <code>cognito:preferred_role</code> claims in the
+     *             token.</p>
+     */
+    RoleArn?: string;
+    /**
+     * <p>The new precedence value for the group. For more information about this parameter, see
+     *                 <a href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_CreateGroup.html">CreateGroup</a>.</p>
+     */
+    Precedence?: number;
+}
+export declare namespace UpdateGroupRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateGroupRequest) => any;
+}
+export interface UpdateGroupResponse {
+    /**
+     * <p>The group object for the group.</p>
+     */
+    Group?: GroupType;
+}
+export declare namespace UpdateGroupResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateGroupResponse) => any;
+}
+export interface UpdateIdentityProviderRequest {
+    /**
+     * <p>The user pool ID.</p>
+     */
+    UserPoolId: string | undefined;
+    /**
+     * <p>The identity provider name.</p>
+     */
+    ProviderName: string | undefined;
+    /**
+     * <p>The identity provider details to be updated, such as <code>MetadataURL</code> and
+     *                 <code>MetadataFile</code>.</p>
+     */
+    ProviderDetails?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>The identity provider attribute mapping to be changed.</p>
+     */
+    AttributeMapping?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>A list of identity provider identifiers.</p>
+     */
+    IdpIdentifiers?: string[];
+}
+export declare namespace UpdateIdentityProviderRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateIdentityProviderRequest) => any;
+}
+export interface UpdateIdentityProviderResponse {
+    /**
+     * <p>The identity provider object.</p>
+     */
+    IdentityProvider: IdentityProviderType | undefined;
+}
+export declare namespace UpdateIdentityProviderResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateIdentityProviderResponse) => any;
+}
+export interface UpdateResourceServerRequest {
+    /**
+     * <p>The user pool ID for the user pool.</p>
+     */
+    UserPoolId: string | undefined;
+    /**
+     * <p>The identifier for the resource server.</p>
+     */
+    Identifier: string | undefined;
+    /**
+     * <p>The name of the resource server.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>The scope values to be set for the resource server.</p>
+     */
+    Scopes?: ResourceServerScopeType[];
+}
+export declare namespace UpdateResourceServerRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateResourceServerRequest) => any;
+}
+export interface UpdateResourceServerResponse {
+    /**
+     * <p>The resource server.</p>
+     */
+    ResourceServer: ResourceServerType | undefined;
+}
+export declare namespace UpdateResourceServerResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateResourceServerResponse) => any;
+}
+/**
+ * <p>Represents the request to update user attributes.</p>
+ */
+export interface UpdateUserAttributesRequest {
+    /**
+     * <p>An array of name-value pairs representing user attributes.</p>
+     *         <p>For custom attributes, you must prepend the <code>custom:</code> prefix to the
+     *             attribute name.</p>
+     */
+    UserAttributes: AttributeType[] | undefined;
+    /**
+     * <p>The access token for the request to update user attributes.</p>
+     */
+    AccessToken: string | undefined;
+    /**
+     * <p>A map of custom key-value pairs that you can provide as input for any custom workflows
+     *             that this action triggers. </p>
+     *         <p>You create custom workflows by assigning Lambda functions to user pool triggers.
+     *             When you use the UpdateUserAttributes API action, Amazon Cognito invokes the function
+     *             that is assigned to the <i>custom message</i> trigger. When Amazon Cognito
+     *             invokes this function, it passes a JSON payload, which the function receives as input.
+     *             This payload contains a <code>clientMetadata</code> attribute, which provides the data
+     *             that you assigned to the ClientMetadata parameter in your UpdateUserAttributes request.
+     *             In your function code in Lambda, you can process the <code>clientMetadata</code>
+     *             value to enhance your workflow for your specific needs.</p>
+     *         <p>For more information, see <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-working-with-aws-lambda-triggers.html">Customizing User Pool Workflows with Lambda Triggers</a> in the
+     *                 <i>Amazon Cognito Developer Guide</i>.</p>
+     *         <note>
+     *             <p>Take the following limitations into consideration when you use the ClientMetadata
+     *                 parameter:</p>
+     *             <ul>
+     *                <li>
+     *                     <p>Amazon Cognito does not store the ClientMetadata value. This data is
+     *                         available only to Lambda triggers that are assigned to a user pool to
+     *                         support custom workflows. If your user pool configuration does not include
+     *                         triggers, the ClientMetadata parameter serves no purpose.</p>
+     *                 </li>
+     *                <li>
+     *                     <p>Amazon Cognito does not validate the ClientMetadata value.</p>
+     *                 </li>
+     *                <li>
+     *                     <p>Amazon Cognito does not encrypt the the ClientMetadata value, so don't use
+     *                         it to provide sensitive information.</p>
+     *                 </li>
+     *             </ul>
+     *         </note>
+     */
+    ClientMetadata?: {
+        [key: string]: string;
+    };
+}
+export declare namespace UpdateUserAttributesRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateUserAttributesRequest) => any;
+}
+/**
+ * <p>Represents the response from the server for the request to update user
+ *             attributes.</p>
+ */
+export interface UpdateUserAttributesResponse {
+    /**
+     * <p>The code delivery details list from the server for the request to update user
+     *             attributes.</p>
+     */
+    CodeDeliveryDetailsList?: CodeDeliveryDetailsType[];
+}
+export declare namespace UpdateUserAttributesResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateUserAttributesResponse) => any;
+}
+/**
+ * <p>Represents the request to update the user pool.</p>
+ */
+export interface UpdateUserPoolRequest {
+    /**
+     * <p>The user pool ID for the user pool you want to update.</p>
+     */
+    UserPoolId: string | undefined;
+    /**
+     * <p>A container with the policies you wish to update in a user pool.</p>
+     */
+    Policies?: UserPoolPolicyType;
+    /**
+     * <p>The Lambda configuration information from the request to update the user
+     *             pool.</p>
+     */
+    LambdaConfig?: LambdaConfigType;
+    /**
+     * <p>The attributes that are automatically verified when the Amazon Cognito service makes a
+     *             request to update user pools.</p>
+     */
+    AutoVerifiedAttributes?: (VerifiedAttributeType | string)[];
+    /**
+     * <p>A container with information about the SMS verification message.</p>
+     */
+    SmsVerificationMessage?: string;
+    /**
+     * <p>The contents of the email verification message.</p>
+     */
+    EmailVerificationMessage?: string;
+    /**
+     * <p>The subject of the email verification message.</p>
+     */
+    EmailVerificationSubject?: string;
+    /**
+     * <p>The template for verification messages.</p>
+     */
+    VerificationMessageTemplate?: VerificationMessageTemplateType;
+    /**
+     * <p>The contents of the SMS authentication message.</p>
+     */
+    SmsAuthenticationMessage?: string;
+    /**
+     * <p>Can be one of the following values:</p>
+     *         <ul>
+     *             <li>
+     *                 <p>
+     *                     <code>OFF</code> - MFA tokens are not required and cannot be specified during
+     *                     user registration.</p>
+     *             </li>
+     *             <li>
+     *                 <p>
+     *                     <code>ON</code> - MFA tokens are required for all user registrations. You can
+     *                     only specify ON when you are initially creating a user pool. You can use the
+     *                         <a href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_SetUserPoolMfaConfig.html">SetUserPoolMfaConfig</a> API operation to turn MFA "ON" for existing
+     *                     user pools. </p>
+     *             </li>
+     *             <li>
+     *                 <p>
+     *                     <code>OPTIONAL</code> - Users have the option when registering to create an MFA
+     *                     token.</p>
+     *             </li>
+     *          </ul>
+     */
+    MfaConfiguration?: UserPoolMfaType | string;
+    /**
+     * <p>Device configuration.</p>
+     */
+    DeviceConfiguration?: DeviceConfigurationType;
+    /**
+     * <p>Email configuration.</p>
+     */
+    EmailConfiguration?: EmailConfigurationType;
+    /**
+     * <p>SMS configuration.</p>
+     */
+    SmsConfiguration?: SmsConfigurationType;
+    /**
+     * <p>The tag keys and values to assign to the user pool. A tag is a label that you can use
+     *             to categorize and manage user pools in different ways, such as by purpose, owner,
+     *             environment, or other criteria.</p>
+     */
+    UserPoolTags?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>The configuration for <code>AdminCreateUser</code> requests.</p>
+     */
+    AdminCreateUserConfig?: AdminCreateUserConfigType;
+    /**
+     * <p>Used to enable advanced security risk detection. Set the key
+     *                 <code>AdvancedSecurityMode</code> to the value "AUDIT".</p>
+     */
+    UserPoolAddOns?: UserPoolAddOnsType;
+    /**
+     * <p>Use this setting to define which verified available method a user can use to recover
+     *             their password when they call <code>ForgotPassword</code>. 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.</p>
+     */
+    AccountRecoverySetting?: AccountRecoverySettingType;
+}
+export declare namespace UpdateUserPoolRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateUserPoolRequest) => any;
+}
+/**
+ * <p>Represents the response from the server when you make a request to update the user
+ *             pool.</p>
+ */
+export interface UpdateUserPoolResponse {
+}
+export declare namespace UpdateUserPoolResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateUserPoolResponse) => any;
+}
+/**
+ * <p>Represents the request to update the user pool client.</p>
+ */
+export interface UpdateUserPoolClientRequest {
+    /**
+     * <p>The user pool ID for the user pool where you want to update the user pool
+     *             client.</p>
+     */
+    UserPoolId: string | undefined;
+    /**
+     * <p>The ID of the client associated with the user pool.</p>
+     */
+    ClientId: string | undefined;
+    /**
+     * <p>The client name from the update user pool client request.</p>
+     */
+    ClientName?: string;
+    /**
+     * <p>The time limit, in days, after which the refresh token is no longer valid and cannot
+     *             be used.</p>
+     */
+    RefreshTokenValidity?: number;
+    /**
+     * <p>The time limit, after which the access token is no longer valid and cannot be
+     *             used.</p>
+     */
+    AccessTokenValidity?: number;
+    /**
+     * <p>The time limit, after which the ID token is no longer valid and cannot be used.</p>
+     */
+    IdTokenValidity?: number;
+    /**
+     * <p>The units in which the validity times are represented in. Default for RefreshToken is
+     *             days, and default for ID and access tokens are hours.</p>
+     */
+    TokenValidityUnits?: TokenValidityUnitsType;
+    /**
+     * <p>The read-only attributes of the user pool.</p>
+     */
+    ReadAttributes?: string[];
+    /**
+     * <p>The writeable attributes of the user pool.</p>
+     */
+    WriteAttributes?: string[];
+    /**
+     * <p>The authentication flows that are supported by the user pool clients. Flow names
+     *             without the <code>ALLOW_</code> prefix are deprecated in favor of new names with the
+     *                 <code>ALLOW_</code> prefix. Note that values with <code>ALLOW_</code> prefix cannot
+     *             be used along with values without <code>ALLOW_</code> prefix.</p>
+     *         <p>Valid values include:</p>
+     *         <ul>
+     *             <li>
+     *                 <p>
+     *                   <code>ALLOW_ADMIN_USER_PASSWORD_AUTH</code>: Enable admin based user password
+     *                     authentication flow <code>ADMIN_USER_PASSWORD_AUTH</code>. This setting replaces
+     *                     the <code>ADMIN_NO_SRP_AUTH</code> 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.</p>
+     *             </li>
+     *             <li>
+     *                 <p>
+     *                   <code>ALLOW_CUSTOM_AUTH</code>: Enable Lambda trigger based
+     *                     authentication.</p>
+     *             </li>
+     *             <li>
+     *                 <p>
+     *                   <code>ALLOW_USER_PASSWORD_AUTH</code>: Enable user password-based
+     *                     authentication. In this flow, Cognito receives the password in the request
+     *                     instead of using the SRP protocol to verify passwords.</p>
+     *             </li>
+     *             <li>
+     *                 <p>
+     *                   <code>ALLOW_USER_SRP_AUTH</code>: Enable SRP based authentication.</p>
+     *             </li>
+     *             <li>
+     *                 <p>
+     *                   <code>ALLOW_REFRESH_TOKEN_AUTH</code>: Enable authflow to refresh
+     *                     tokens.</p>
+     *             </li>
+     *          </ul>
+     */
+    ExplicitAuthFlows?: (ExplicitAuthFlowsType | string)[];
+    /**
+     * <p>A list of provider names for the identity providers that are supported on this
+     *             client.</p>
+     */
+    SupportedIdentityProviders?: string[];
+    /**
+     * <p>A list of allowed redirect (callback) URLs for the identity providers.</p>
+     *         <p>A redirect URI must:</p>
+     *         <ul>
+     *             <li>
+     *                 <p>Be an absolute URI.</p>
+     *             </li>
+     *             <li>
+     *                 <p>Be registered with the authorization server.</p>
+     *             </li>
+     *             <li>
+     *                 <p>Not include a fragment component.</p>
+     *             </li>
+     *          </ul>
+     *         <p>See <a href="https://tools.ietf.org/html/rfc6749#section-3.1.2">OAuth 2.0 -
+     *                 Redirection Endpoint</a>.</p>
+     *         <p>Amazon Cognito requires HTTPS over HTTP except for http://localhost for testing
+     *             purposes only.</p>
+     *         <p>App callback URLs such as myapp://example are also supported.</p>
+     */
+    CallbackURLs?: string[];
+    /**
+     * <p>A list of allowed logout URLs for the identity providers.</p>
+     */
+    LogoutURLs?: string[];
+    /**
+     * <p>The default redirect URI. Must be in the <code>CallbackURLs</code> list.</p>
+     *         <p>A redirect URI must:</p>
+     *         <ul>
+     *             <li>
+     *                 <p>Be an absolute URI.</p>
+     *             </li>
+     *             <li>
+     *                 <p>Be registered with the authorization server.</p>
+     *             </li>
+     *             <li>
+     *                 <p>Not include a fragment component.</p>
+     *             </li>
+     *          </ul>
+     *         <p>See <a href="https://tools.ietf.org/html/rfc6749#section-3.1.2">OAuth 2.0 -
+     *                 Redirection Endpoint</a>.</p>
+     *         <p>Amazon Cognito requires HTTPS over HTTP except for http://localhost for testing
+     *             purposes only.</p>
+     *         <p>App callback URLs such as myapp://example are also supported.</p>
+     */
+    DefaultRedirectURI?: string;
+    /**
+     * <p>The allowed OAuth flows.</p>
+     *         <p>Set to <code>code</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.</p>
+     *         <p>Set to <code>implicit</code> to specify that the client should get the access token
+     *             (and, optionally, ID token, based on scopes) directly.</p>
+     *         <p>Set to <code>client_credentials</code> 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.</p>
+     */
+    AllowedOAuthFlows?: (OAuthFlowType | string)[];
+    /**
+     * <p>The allowed OAuth scopes. Possible values provided by OAuth are: <code>phone</code>,
+     *                 <code>email</code>, <code>openid</code>, and <code>profile</code>. Possible values
+     *             provided by Amazon Web Services are: <code>aws.cognito.signin.user.admin</code>. Custom scopes created
+     *             in Resource Servers are also supported.</p>
+     */
+    AllowedOAuthScopes?: string[];
+    /**
+     * <p>Set to true if the client is allowed to follow the OAuth protocol when interacting
+     *             with Cognito user pools.</p>
+     */
+    AllowedOAuthFlowsUserPoolClient?: boolean;
+    /**
+     * <p>The Amazon Pinpoint analytics configuration for collecting metrics for this user
+     *             pool.</p>
+     *         <note>
+     *             <p>In regions where Pinpoint is not available, Cognito User Pools only supports
+     *                 sending events to Amazon Pinpoint projects in us-east-1. In regions where Pinpoint
+     *                 is available, Cognito User Pools will support sending events to Amazon Pinpoint
+     *                 projects within that same region. </p>
+     *         </note>
+     */
+    AnalyticsConfiguration?: AnalyticsConfigurationType;
+    /**
+     * <p>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 <code>ENABLED</code> 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 <code>LEGACY</code>, those APIs
+     *             will return a <code>UserNotFoundException</code> exception if the user does not exist in
+     *             the user pool.</p>
+     *         <p>Valid values include:</p>
+     *         <ul>
+     *             <li>
+     *                 <p>
+     *                   <code>ENABLED</code> - This prevents user existence-related errors.</p>
+     *             </li>
+     *             <li>
+     *                 <p>
+     *                   <code>LEGACY</code> - This represents the old behavior of Cognito where user
+     *                     existence related errors are not prevented.</p>
+     *             </li>
+     *          </ul>
+     *
+     *
+     *         <note>
+     *             <p>After February 15th 2020, the value of <code>PreventUserExistenceErrors</code>
+     *                 will default to <code>ENABLED</code> for newly created user pool clients if no value
+     *                 is provided.</p>
+     *         </note>
+     */
+    PreventUserExistenceErrors?: PreventUserExistenceErrorTypes | string;
+    /**
+     * <p>Enables or disables token revocation. For more information
+     *             about revoking tokens, see <a href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RevokeToken.html">RevokeToken</a>.</p>
+     */
+    EnableTokenRevocation?: boolean;
+}
+export declare namespace UpdateUserPoolClientRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateUserPoolClientRequest) => any;
+}
+/**
+ * <p>Represents the response from the server to the request to update the user pool
+ *             client.</p>
+ */
+export interface UpdateUserPoolClientResponse {
+    /**
+     * <p>The user pool client value from the response from the server when an update user pool
+     *             client request is made.</p>
+     */
+    UserPoolClient?: UserPoolClientType;
+}
+export declare namespace UpdateUserPoolClientResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateUserPoolClientResponse) => any;
+}
+/**
+ * <p>The UpdateUserPoolDomain request input.</p>
+ */
+export interface UpdateUserPoolDomainRequest {
+    /**
+     * <p>The domain name for the custom domain that hosts the sign-up and sign-in pages for
+     *             your application. For example: <code>auth.example.com</code>. </p>
+     *         <p>This string can include only lowercase letters, numbers, and hyphens. Do not use a
+     *             hyphen for the first or last character. Use periods to separate subdomain names.</p>
+     */
+    Domain: string | undefined;
+    /**
+     * <p>The ID of the user pool that is associated with the custom domain that you are
+     *             updating the certificate for.</p>
+     */
+    UserPoolId: string | undefined;
+    /**
+     * <p>The configuration for a custom domain that hosts the sign-up and sign-in pages for
+     *             your application. Use this object to specify an SSL certificate that is managed by
+     *             ACM.</p>
+     */
+    CustomDomainConfig: CustomDomainConfigType | undefined;
+}
+export declare namespace UpdateUserPoolDomainRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateUserPoolDomainRequest) => any;
+}
+/**
+ * <p>The UpdateUserPoolDomain response output.</p>
+ */
+export interface UpdateUserPoolDomainResponse {
+    /**
+     * <p>The Amazon CloudFront endpoint that Amazon Cognito set up when you added the custom
+     *             domain to your user pool.</p>
+     */
+    CloudFrontDomain?: string;
+}
+export declare namespace UpdateUserPoolDomainResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateUserPoolDomainResponse) => any;
+}
+/**
+ * <p>This exception is thrown when there is a code mismatch and the service fails to
+ *             configure the software token TOTP multi-factor authentication (MFA).</p>
+ */
+export interface EnableSoftwareTokenMFAException extends __SmithyException, $MetadataBearer {
+    name: "EnableSoftwareTokenMFAException";
+    $fault: "client";
+    message?: string;
+}
+export declare namespace EnableSoftwareTokenMFAException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: EnableSoftwareTokenMFAException) => any;
+}
+export interface VerifySoftwareTokenRequest {
+    /**
+     * <p>The access token.</p>
+     */
+    AccessToken?: string;
+    /**
+     * <p>The session which should be passed both ways in challenge-response calls to the
+     *             service.</p>
+     */
+    Session?: string;
+    /**
+     * <p>The one time password computed using the secret code returned by <a href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AssociateSoftwareToken.html">AssociateSoftwareToken"</a>.</p>
+     */
+    UserCode: string | undefined;
+    /**
+     * <p>The friendly device name.</p>
+     */
+    FriendlyDeviceName?: string;
+}
+export declare namespace VerifySoftwareTokenRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: VerifySoftwareTokenRequest) => any;
+}
+export declare enum VerifySoftwareTokenResponseType {
+    ERROR = "ERROR",
+    SUCCESS = "SUCCESS"
+}
+export interface VerifySoftwareTokenResponse {
+    /**
+     * <p>The status of the verify software token.</p>
+     */
+    Status?: VerifySoftwareTokenResponseType | string;
+    /**
+     * <p>The session which should be passed both ways in challenge-response calls to the
+     *             service.</p>
+     */
+    Session?: string;
+}
+export declare namespace VerifySoftwareTokenResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: VerifySoftwareTokenResponse) => any;
+}
+/**
+ * <p>Represents the request to verify user attributes.</p>
+ */
+export interface VerifyUserAttributeRequest {
+    /**
+     * <p>Represents the access token of the request to verify user attributes.</p>
+     */
+    AccessToken: string | undefined;
+    /**
+     * <p>The attribute name in the request to verify user attributes.</p>
+     */
+    AttributeName: string | undefined;
+    /**
+     * <p>The verification code in the request to verify user attributes.</p>
+     */
+    Code: string | undefined;
+}
+export declare namespace VerifyUserAttributeRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: VerifyUserAttributeRequest) => any;
+}
+/**
+ * <p>A container representing the response from the server from the request to verify user
+ *             attributes.</p>
+ */
+export interface VerifyUserAttributeResponse {
+}
+export declare namespace VerifyUserAttributeResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: VerifyUserAttributeResponse) => any;
+}