@aws-sdk/client-cognito-identity-provider 3.34.0 → 3.37.0

package/dist-types/commands/ListIdentityProvidersCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { ListIdentityProvidersRequest, ListIdentityProvidersResponse } from "../models/models_0";
+export interface ListIdentityProvidersCommandInput extends ListIdentityProvidersRequest {
+}
+export interface ListIdentityProvidersCommandOutput extends ListIdentityProvidersResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists information about all identity providers for a user pool.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, ListIdentityProvidersCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, ListIdentityProvidersCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new ListIdentityProvidersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListIdentityProvidersCommandInput} for command's `input` shape.
+ * @see {@link ListIdentityProvidersCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListIdentityProvidersCommand extends $Command<ListIdentityProvidersCommandInput, ListIdentityProvidersCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: ListIdentityProvidersCommandInput;
+    constructor(input: ListIdentityProvidersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListIdentityProvidersCommandInput, ListIdentityProvidersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListResourceServersCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { ListResourceServersRequest, ListResourceServersResponse } from "../models/models_0";
+export interface ListResourceServersCommandInput extends ListResourceServersRequest {
+}
+export interface ListResourceServersCommandOutput extends ListResourceServersResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the resource servers for a user pool.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, ListResourceServersCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, ListResourceServersCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new ListResourceServersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListResourceServersCommandInput} for command's `input` shape.
+ * @see {@link ListResourceServersCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListResourceServersCommand extends $Command<ListResourceServersCommandInput, ListResourceServersCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: ListResourceServersCommandInput;
+    constructor(input: ListResourceServersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListResourceServersCommandInput, ListResourceServersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListTagsForResourceCommand.d.ts

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { ListTagsForResourceRequest, ListTagsForResourceResponse } from "../models/models_0";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequest {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the tags that are assigned to an Amazon Cognito user pool.</p>
+ *         <p>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.</p>
+ *         <p>You can use this action up to 10 times per second, per account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, ListTagsForResourceCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, ListTagsForResourceCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListUserImportJobsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { ListUserImportJobsRequest, ListUserImportJobsResponse } from "../models/models_0";
+export interface ListUserImportJobsCommandInput extends ListUserImportJobsRequest {
+}
+export interface ListUserImportJobsCommandOutput extends ListUserImportJobsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the user import jobs.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, ListUserImportJobsCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, ListUserImportJobsCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new ListUserImportJobsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListUserImportJobsCommandInput} for command's `input` shape.
+ * @see {@link ListUserImportJobsCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListUserImportJobsCommand extends $Command<ListUserImportJobsCommandInput, ListUserImportJobsCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: ListUserImportJobsCommandInput;
+    constructor(input: ListUserImportJobsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListUserImportJobsCommandInput, ListUserImportJobsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListUserPoolClientsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { ListUserPoolClientsRequest, ListUserPoolClientsResponse } from "../models/models_0";
+export interface ListUserPoolClientsCommandInput extends ListUserPoolClientsRequest {
+}
+export interface ListUserPoolClientsCommandOutput extends ListUserPoolClientsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the clients that have been created for the specified user pool.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, ListUserPoolClientsCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, ListUserPoolClientsCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new ListUserPoolClientsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListUserPoolClientsCommandInput} for command's `input` shape.
+ * @see {@link ListUserPoolClientsCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListUserPoolClientsCommand extends $Command<ListUserPoolClientsCommandInput, ListUserPoolClientsCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: ListUserPoolClientsCommandInput;
+    constructor(input: ListUserPoolClientsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListUserPoolClientsCommandInput, ListUserPoolClientsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListUserPoolsCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { ListUserPoolsRequest, ListUserPoolsResponse } from "../models/models_0";
+export interface ListUserPoolsCommandInput extends ListUserPoolsRequest {
+}
+export interface ListUserPoolsCommandOutput extends ListUserPoolsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the user pools associated with an account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, ListUserPoolsCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, ListUserPoolsCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new ListUserPoolsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListUserPoolsCommandInput} for command's `input` shape.
+ * @see {@link ListUserPoolsCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListUserPoolsCommand extends $Command<ListUserPoolsCommandInput, ListUserPoolsCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: ListUserPoolsCommandInput;
+    constructor(input: ListUserPoolsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListUserPoolsCommandInput, ListUserPoolsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListUsersCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { ListUsersRequest, ListUsersResponse } from "../models/models_0";
+export interface ListUsersCommandInput extends ListUsersRequest {
+}
+export interface ListUsersCommandOutput extends ListUsersResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the users in the Amazon Cognito user pool.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, ListUsersCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, ListUsersCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new ListUsersCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListUsersCommandInput} for command's `input` shape.
+ * @see {@link ListUsersCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListUsersCommand extends $Command<ListUsersCommandInput, ListUsersCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: ListUsersCommandInput;
+    constructor(input: ListUsersCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListUsersCommandInput, ListUsersCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListUsersInGroupCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { ListUsersInGroupRequest, ListUsersInGroupResponse } from "../models/models_0";
+export interface ListUsersInGroupCommandInput extends ListUsersInGroupRequest {
+}
+export interface ListUsersInGroupCommandOutput extends ListUsersInGroupResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the users in the specified group.</p>
+ *         <p>Calling this action requires developer credentials.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, ListUsersInGroupCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, ListUsersInGroupCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new ListUsersInGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListUsersInGroupCommandInput} for command's `input` shape.
+ * @see {@link ListUsersInGroupCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListUsersInGroupCommand extends $Command<ListUsersInGroupCommandInput, ListUsersInGroupCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: ListUsersInGroupCommandInput;
+    constructor(input: ListUsersInGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListUsersInGroupCommandInput, ListUsersInGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ResendConfirmationCodeCommand.d.ts

@@ -0,0 +1,53 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { ResendConfirmationCodeRequest, ResendConfirmationCodeResponse } from "../models/models_0";
+export interface ResendConfirmationCodeCommandInput extends ResendConfirmationCodeRequest {
+}
+export interface ResendConfirmationCodeCommandOutput extends ResendConfirmationCodeResponse, __MetadataBearer {
+}
+/**
+ * <p>Resends the confirmation (for confirmation of registration) to a specific user in the
+ *             user pool.</p>
+ *
+ *         <note>
+ *             <p>This action might generate an SMS text message. Starting June 1, 2021, U.S.
+ *                 telecom carriers require that you register an origination phone number before you can
+ *                 send SMS messages to U.S. phone numbers. If you use SMS text messages in Amazon Cognito,
+ *                 you must register a phone number with <a href="https://console.aws.amazon.com/pinpoint/home/">Amazon Pinpoint</a>.
+ *                 Cognito  will use the the registered number automatically. Otherwise, Cognito users that must
+ *                 receive SMS messages might be unable to sign up, activate their accounts, or sign
+ *                 in.</p>
+ *             <p>If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Service, Amazon SNS might place your account in SMS sandbox. In <i>
+ *                   <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html">sandbox
+ *                     mode</a>
+ *                </i>, you’ll have limitations, such as sending messages
+ *                 to only verified phone numbers. After testing in the sandbox environment, you can
+ *                 move out of the SMS sandbox and into production. For more information, see <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html"> SMS message settings for Cognito User Pools</a> in the <i>Amazon
+ *                         Cognito Developer Guide</i>. </p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, ResendConfirmationCodeCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, ResendConfirmationCodeCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new ResendConfirmationCodeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ResendConfirmationCodeCommandInput} for command's `input` shape.
+ * @see {@link ResendConfirmationCodeCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ResendConfirmationCodeCommand extends $Command<ResendConfirmationCodeCommandInput, ResendConfirmationCodeCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: ResendConfirmationCodeCommandInput;
+    constructor(input: ResendConfirmationCodeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResendConfirmationCodeCommandInput, ResendConfirmationCodeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RespondToAuthChallengeCommand.d.ts

@@ -0,0 +1,52 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { RespondToAuthChallengeRequest, RespondToAuthChallengeResponse } from "../models/models_0";
+export interface RespondToAuthChallengeCommandInput extends RespondToAuthChallengeRequest {
+}
+export interface RespondToAuthChallengeCommandOutput extends RespondToAuthChallengeResponse, __MetadataBearer {
+}
+/**
+ * <p>Responds to the authentication challenge.</p>
+ *
+ *         <note>
+ *             <p>This action might generate an SMS text message. Starting June 1, 2021, U.S.
+ *                 telecom carriers require that you register an origination phone number before you can
+ *                 send SMS messages to U.S. phone numbers. If you use SMS text messages in Amazon Cognito,
+ *                 you must register a phone number with <a href="https://console.aws.amazon.com/pinpoint/home/">Amazon Pinpoint</a>.
+ *                 Cognito  will use the the registered number automatically. Otherwise, Cognito users that must
+ *                 receive SMS messages might be unable to sign up, activate their accounts, or sign
+ *                 in.</p>
+ *             <p>If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Service, Amazon SNS might place your account in SMS sandbox. In <i>
+ *                   <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html">sandbox
+ *                     mode</a>
+ *                </i>, you’ll have limitations, such as sending messages
+ *                 to only verified phone numbers. After testing in the sandbox environment, you can
+ *                 move out of the SMS sandbox and into production. For more information, see <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html"> SMS message settings for Cognito User Pools</a> in the <i>Amazon
+ *                         Cognito Developer Guide</i>. </p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, RespondToAuthChallengeCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, RespondToAuthChallengeCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new RespondToAuthChallengeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RespondToAuthChallengeCommandInput} for command's `input` shape.
+ * @see {@link RespondToAuthChallengeCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RespondToAuthChallengeCommand extends $Command<RespondToAuthChallengeCommandInput, RespondToAuthChallengeCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: RespondToAuthChallengeCommandInput;
+    constructor(input: RespondToAuthChallengeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RespondToAuthChallengeCommandInput, RespondToAuthChallengeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/RevokeTokenCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { RevokeTokenRequest, RevokeTokenResponse } from "../models/models_0";
+export interface RevokeTokenCommandInput extends RevokeTokenRequest {
+}
+export interface RevokeTokenCommandOutput extends RevokeTokenResponse, __MetadataBearer {
+}
+/**
+ * <p>Revokes all of the access tokens generated by the specified refresh token. After the token is revoked, you can not
+ *             use the revoked token to access Cognito authenticated APIs.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, RevokeTokenCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, RevokeTokenCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new RevokeTokenCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RevokeTokenCommandInput} for command's `input` shape.
+ * @see {@link RevokeTokenCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RevokeTokenCommand extends $Command<RevokeTokenCommandInput, RevokeTokenCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: RevokeTokenCommandInput;
+    constructor(input: RevokeTokenCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RevokeTokenCommandInput, RevokeTokenCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SetRiskConfigurationCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { SetRiskConfigurationRequest, SetRiskConfigurationResponse } from "../models/models_0";
+export interface SetRiskConfigurationCommandInput extends SetRiskConfigurationRequest {
+}
+export interface SetRiskConfigurationCommandOutput extends SetRiskConfigurationResponse, __MetadataBearer {
+}
+/**
+ * <p>Configures actions on detected risks. To delete the risk configuration for
+ *                 <code>UserPoolId</code> or <code>ClientId</code>, pass null values for all four
+ *             configuration types.</p>
+ *         <p>To enable Amazon Cognito advanced security features, update the user pool to include
+ *             the <code>UserPoolAddOns</code> key<code>AdvancedSecurityMode</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, SetRiskConfigurationCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, SetRiskConfigurationCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new SetRiskConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetRiskConfigurationCommandInput} for command's `input` shape.
+ * @see {@link SetRiskConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SetRiskConfigurationCommand extends $Command<SetRiskConfigurationCommandInput, SetRiskConfigurationCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: SetRiskConfigurationCommandInput;
+    constructor(input: SetRiskConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetRiskConfigurationCommandInput, SetRiskConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SetUICustomizationCommand.d.ts

@@ -0,0 +1,46 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { SetUICustomizationRequest, SetUICustomizationResponse } from "../models/models_0";
+export interface SetUICustomizationCommandInput extends SetUICustomizationRequest {
+}
+export interface SetUICustomizationCommandOutput extends SetUICustomizationResponse, __MetadataBearer {
+}
+/**
+ * <p>Sets the UI customization information for a user pool's built-in app UI.</p>
+ *         <p>You can specify app UI customization settings for a single client (with a specific
+ *                 <code>clientId</code>) or for all clients (by setting the <code>clientId</code> to
+ *                 <code>ALL</code>). If you specify <code>ALL</code>, the default configuration will
+ *             be used for every client that has no UI customization set previously. If you specify UI
+ *             customization settings for a particular client, it will no longer fall back to the
+ *                 <code>ALL</code> configuration. </p>
+ *         <note>
+ *             <p>To use this API, your user pool must have a domain associated with it. Otherwise,
+ *                 there is no place to host the app's pages, and the service will throw an
+ *                 error.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, SetUICustomizationCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, SetUICustomizationCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new SetUICustomizationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetUICustomizationCommandInput} for command's `input` shape.
+ * @see {@link SetUICustomizationCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SetUICustomizationCommand extends $Command<SetUICustomizationCommandInput, SetUICustomizationCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: SetUICustomizationCommandInput;
+    constructor(input: SetUICustomizationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetUICustomizationCommandInput, SetUICustomizationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SetUserMFAPreferenceCommand.d.ts

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { SetUserMFAPreferenceRequest, SetUserMFAPreferenceResponse } from "../models/models_0";
+export interface SetUserMFAPreferenceCommandInput extends SetUserMFAPreferenceRequest {
+}
+export interface SetUserMFAPreferenceCommandOutput extends SetUserMFAPreferenceResponse, __MetadataBearer {
+}
+/**
+ * <p>Set the user's multi-factor authentication (MFA) method preference, including which
+ *             MFA factors are enabled and if any are preferred. Only one factor can be set as
+ *             preferred. The preferred MFA factor will be used to authenticate a user if multiple
+ *             factors are enabled. If multiple options are enabled and no preference is set, a
+ *             challenge to choose an MFA option will be returned during sign in. If an MFA type is
+ *             enabled 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,
+ *             disable MFA for users and turn on Adaptive Authentication for the user pool.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, SetUserMFAPreferenceCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, SetUserMFAPreferenceCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new SetUserMFAPreferenceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetUserMFAPreferenceCommandInput} for command's `input` shape.
+ * @see {@link SetUserMFAPreferenceCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SetUserMFAPreferenceCommand extends $Command<SetUserMFAPreferenceCommandInput, SetUserMFAPreferenceCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: SetUserMFAPreferenceCommandInput;
+    constructor(input: SetUserMFAPreferenceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetUserMFAPreferenceCommandInput, SetUserMFAPreferenceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/SetUserPoolMfaConfigCommand.d.ts

@@ -0,0 +1,52 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { SetUserPoolMfaConfigRequest, SetUserPoolMfaConfigResponse } from "../models/models_0";
+export interface SetUserPoolMfaConfigCommandInput extends SetUserPoolMfaConfigRequest {
+}
+export interface SetUserPoolMfaConfigCommandOutput extends SetUserPoolMfaConfigResponse, __MetadataBearer {
+}
+/**
+ * <p>Set the user pool multi-factor authentication (MFA) configuration.</p>
+ *
+ *         <note>
+ *             <p>This action might generate an SMS text message. Starting June 1, 2021, U.S.
+ *                 telecom carriers require that you register an origination phone number before you can
+ *                 send SMS messages to U.S. phone numbers. If you use SMS text messages in Amazon Cognito,
+ *                 you must register a phone number with <a href="https://console.aws.amazon.com/pinpoint/home/">Amazon Pinpoint</a>.
+ *                 Cognito  will use the the registered number automatically. Otherwise, Cognito users that must
+ *                 receive SMS messages might be unable to sign up, activate their accounts, or sign
+ *                 in.</p>
+ *             <p>If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Service, Amazon SNS might place your account in SMS sandbox. In <i>
+ *                   <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html">sandbox
+ *                     mode</a>
+ *                </i>, you’ll have limitations, such as sending messages
+ *                 to only verified phone numbers. After testing in the sandbox environment, you can
+ *                 move out of the SMS sandbox and into production. For more information, see <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html"> SMS message settings for Cognito User Pools</a> in the <i>Amazon
+ *                         Cognito Developer Guide</i>. </p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, SetUserPoolMfaConfigCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, SetUserPoolMfaConfigCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new SetUserPoolMfaConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetUserPoolMfaConfigCommandInput} for command's `input` shape.
+ * @see {@link SetUserPoolMfaConfigCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SetUserPoolMfaConfigCommand extends $Command<SetUserPoolMfaConfigCommandInput, SetUserPoolMfaConfigCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: SetUserPoolMfaConfigCommandInput;
+    constructor(input: SetUserPoolMfaConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetUserPoolMfaConfigCommandInput, SetUserPoolMfaConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}