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

package/dist-types/ts3.4/commands/ForgetDeviceCommand.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 { ForgetDeviceRequest } from "../models/models_0";
+export interface ForgetDeviceCommandInput extends ForgetDeviceRequest {
+}
+export interface ForgetDeviceCommandOutput extends __MetadataBearer {
+}
+/**
+ * <p>Forgets the specified device.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, ForgetDeviceCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, ForgetDeviceCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new ForgetDeviceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ForgetDeviceCommandInput} for command's `input` shape.
+ * @see {@link ForgetDeviceCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ForgetDeviceCommand extends $Command<ForgetDeviceCommandInput, ForgetDeviceCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: ForgetDeviceCommandInput;
+    constructor(input: ForgetDeviceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ForgetDeviceCommandInput, ForgetDeviceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ForgotPasswordCommand.d.ts

@@ -0,0 +1,59 @@
+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 { ForgotPasswordRequest, ForgotPasswordResponse } from "../models/models_0";
+export interface ForgotPasswordCommandInput extends ForgotPasswordRequest {
+}
+export interface ForgotPasswordCommandOutput extends ForgotPasswordResponse, __MetadataBearer {
+}
+/**
+ * <p>Calling this API causes a message to be sent to the end user with a confirmation code
+ *             that is required to change the user's password. For the <code>Username</code> parameter,
+ *             you can use the username or user alias. The method used to send the confirmation code is
+ *             sent according to the specified AccountRecoverySetting. For more information, see <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/how-to-recover-a-user-account.html">Recovering
+ *                 User Accounts</a> in the <i>Amazon Cognito Developer Guide</i>. If
+ *             neither a verified phone number nor a verified email exists, an
+ *                 <code>InvalidParameterException</code> is thrown. To use the confirmation code for
+ *             resetting the password, call <a href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_ConfirmForgotPassword.html">ConfirmForgotPassword</a>.</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, ForgotPasswordCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, ForgotPasswordCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new ForgotPasswordCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ForgotPasswordCommandInput} for command's `input` shape.
+ * @see {@link ForgotPasswordCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ForgotPasswordCommand extends $Command<ForgotPasswordCommandInput, ForgotPasswordCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: ForgotPasswordCommandInput;
+    constructor(input: ForgotPasswordCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ForgotPasswordCommandInput, ForgotPasswordCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetCSVHeaderCommand.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 { GetCSVHeaderRequest, GetCSVHeaderResponse } from "../models/models_0";
+export interface GetCSVHeaderCommandInput extends GetCSVHeaderRequest {
+}
+export interface GetCSVHeaderCommandOutput extends GetCSVHeaderResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the header information for the .csv file to be used as input for the user import
+ *             job.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, GetCSVHeaderCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, GetCSVHeaderCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new GetCSVHeaderCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCSVHeaderCommandInput} for command's `input` shape.
+ * @see {@link GetCSVHeaderCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetCSVHeaderCommand extends $Command<GetCSVHeaderCommandInput, GetCSVHeaderCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: GetCSVHeaderCommandInput;
+    constructor(input: GetCSVHeaderCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCSVHeaderCommandInput, GetCSVHeaderCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetDeviceCommand.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 { GetDeviceRequest, GetDeviceResponse } from "../models/models_0";
+export interface GetDeviceCommandInput extends GetDeviceRequest {
+}
+export interface GetDeviceCommandOutput extends GetDeviceResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the device.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, GetDeviceCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, GetDeviceCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new GetDeviceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetDeviceCommandInput} for command's `input` shape.
+ * @see {@link GetDeviceCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetDeviceCommand extends $Command<GetDeviceCommandInput, GetDeviceCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: GetDeviceCommandInput;
+    constructor(input: GetDeviceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetDeviceCommandInput, GetDeviceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetGroupCommand.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 { GetGroupRequest, GetGroupResponse } from "../models/models_0";
+export interface GetGroupCommandInput extends GetGroupRequest {
+}
+export interface GetGroupCommandOutput extends GetGroupResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets a 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, GetGroupCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, GetGroupCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new GetGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetGroupCommandInput} for command's `input` shape.
+ * @see {@link GetGroupCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetGroupCommand extends $Command<GetGroupCommandInput, GetGroupCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: GetGroupCommandInput;
+    constructor(input: GetGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGroupCommandInput, GetGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetIdentityProviderByIdentifierCommand.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 { GetIdentityProviderByIdentifierRequest, GetIdentityProviderByIdentifierResponse } from "../models/models_0";
+export interface GetIdentityProviderByIdentifierCommandInput extends GetIdentityProviderByIdentifierRequest {
+}
+export interface GetIdentityProviderByIdentifierCommandOutput extends GetIdentityProviderByIdentifierResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the specified identity provider.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, GetIdentityProviderByIdentifierCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, GetIdentityProviderByIdentifierCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new GetIdentityProviderByIdentifierCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetIdentityProviderByIdentifierCommandInput} for command's `input` shape.
+ * @see {@link GetIdentityProviderByIdentifierCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetIdentityProviderByIdentifierCommand extends $Command<GetIdentityProviderByIdentifierCommandInput, GetIdentityProviderByIdentifierCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: GetIdentityProviderByIdentifierCommandInput;
+    constructor(input: GetIdentityProviderByIdentifierCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetIdentityProviderByIdentifierCommandInput, GetIdentityProviderByIdentifierCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetSigningCertificateCommand.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 { GetSigningCertificateRequest, GetSigningCertificateResponse } from "../models/models_0";
+export interface GetSigningCertificateCommandInput extends GetSigningCertificateRequest {
+}
+export interface GetSigningCertificateCommandOutput extends GetSigningCertificateResponse, __MetadataBearer {
+}
+/**
+ * <p>This method takes a user pool ID, and returns the signing certificate.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, GetSigningCertificateCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, GetSigningCertificateCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new GetSigningCertificateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSigningCertificateCommandInput} for command's `input` shape.
+ * @see {@link GetSigningCertificateCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetSigningCertificateCommand extends $Command<GetSigningCertificateCommandInput, GetSigningCertificateCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: GetSigningCertificateCommandInput;
+    constructor(input: GetSigningCertificateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSigningCertificateCommandInput, GetSigningCertificateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetUICustomizationCommand.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 { GetUICustomizationRequest, GetUICustomizationResponse } from "../models/models_0";
+export interface GetUICustomizationCommandInput extends GetUICustomizationRequest {
+}
+export interface GetUICustomizationCommandOutput extends GetUICustomizationResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the UI Customization information for a particular app client's app UI, if there
+ *             is something set. If nothing is set for the particular client, but there is an existing
+ *             pool level customization (app <code>clientId</code> will be <code>ALL</code>), then that
+ *             is returned. If nothing is present, then an empty shape is returned.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, GetUICustomizationCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, GetUICustomizationCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new GetUICustomizationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetUICustomizationCommandInput} for command's `input` shape.
+ * @see {@link GetUICustomizationCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetUICustomizationCommand extends $Command<GetUICustomizationCommandInput, GetUICustomizationCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: GetUICustomizationCommandInput;
+    constructor(input: GetUICustomizationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUICustomizationCommandInput, GetUICustomizationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetUserAttributeVerificationCodeCommand.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 { GetUserAttributeVerificationCodeRequest, GetUserAttributeVerificationCodeResponse } from "../models/models_0";
+export interface GetUserAttributeVerificationCodeCommandInput extends GetUserAttributeVerificationCodeRequest {
+}
+export interface GetUserAttributeVerificationCodeCommandOutput extends GetUserAttributeVerificationCodeResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the user attribute verification code for the specified attribute name.</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, GetUserAttributeVerificationCodeCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, GetUserAttributeVerificationCodeCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new GetUserAttributeVerificationCodeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetUserAttributeVerificationCodeCommandInput} for command's `input` shape.
+ * @see {@link GetUserAttributeVerificationCodeCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetUserAttributeVerificationCodeCommand extends $Command<GetUserAttributeVerificationCodeCommandInput, GetUserAttributeVerificationCodeCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: GetUserAttributeVerificationCodeCommandInput;
+    constructor(input: GetUserAttributeVerificationCodeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUserAttributeVerificationCodeCommandInput, GetUserAttributeVerificationCodeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetUserCommand.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 { GetUserRequest, GetUserResponse } from "../models/models_0";
+export interface GetUserCommandInput extends GetUserRequest {
+}
+export interface GetUserCommandOutput extends GetUserResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the user attributes and metadata for a user.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, GetUserCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, GetUserCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new GetUserCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetUserCommandInput} for command's `input` shape.
+ * @see {@link GetUserCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetUserCommand extends $Command<GetUserCommandInput, GetUserCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: GetUserCommandInput;
+    constructor(input: GetUserCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUserCommandInput, GetUserCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GetUserPoolMfaConfigCommand.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 { GetUserPoolMfaConfigRequest, GetUserPoolMfaConfigResponse } from "../models/models_0";
+export interface GetUserPoolMfaConfigCommandInput extends GetUserPoolMfaConfigRequest {
+}
+export interface GetUserPoolMfaConfigCommandOutput extends GetUserPoolMfaConfigResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the user pool multi-factor authentication (MFA) configuration.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, GetUserPoolMfaConfigCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, GetUserPoolMfaConfigCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new GetUserPoolMfaConfigCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetUserPoolMfaConfigCommandInput} for command's `input` shape.
+ * @see {@link GetUserPoolMfaConfigCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetUserPoolMfaConfigCommand extends $Command<GetUserPoolMfaConfigCommandInput, GetUserPoolMfaConfigCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: GetUserPoolMfaConfigCommandInput;
+    constructor(input: GetUserPoolMfaConfigCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUserPoolMfaConfigCommandInput, GetUserPoolMfaConfigCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/GlobalSignOutCommand.d.ts

@@ -0,0 +1,37 @@
+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 { GlobalSignOutRequest, GlobalSignOutResponse } from "../models/models_0";
+export interface GlobalSignOutCommandInput extends GlobalSignOutRequest {
+}
+export interface GlobalSignOutCommandOutput extends GlobalSignOutResponse, __MetadataBearer {
+}
+/**
+ * <p>Signs out users from all devices. It also invalidates all refresh tokens issued to a
+ *             user. The user's current access and Id tokens remain valid until their expiry. Access
+ *             and Id tokens expire one hour after they are issued.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, GlobalSignOutCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, GlobalSignOutCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new GlobalSignOutCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GlobalSignOutCommandInput} for command's `input` shape.
+ * @see {@link GlobalSignOutCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GlobalSignOutCommand extends $Command<GlobalSignOutCommandInput, GlobalSignOutCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: GlobalSignOutCommandInput;
+    constructor(input: GlobalSignOutCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GlobalSignOutCommandInput, GlobalSignOutCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/InitiateAuthCommand.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 { InitiateAuthRequest, InitiateAuthResponse } from "../models/models_0";
+export interface InitiateAuthCommandInput extends InitiateAuthRequest {
+}
+export interface InitiateAuthCommandOutput extends InitiateAuthResponse, __MetadataBearer {
+}
+/**
+ * <p>Initiates the authentication flow.</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, InitiateAuthCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, InitiateAuthCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new InitiateAuthCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link InitiateAuthCommandInput} for command's `input` shape.
+ * @see {@link InitiateAuthCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class InitiateAuthCommand extends $Command<InitiateAuthCommandInput, InitiateAuthCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: InitiateAuthCommandInput;
+    constructor(input: InitiateAuthCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<InitiateAuthCommandInput, InitiateAuthCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListDevicesCommand.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 { ListDevicesRequest, ListDevicesResponse } from "../models/models_0";
+export interface ListDevicesCommandInput extends ListDevicesRequest {
+}
+export interface ListDevicesCommandOutput extends ListDevicesResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the devices.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, ListDevicesCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, ListDevicesCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new ListDevicesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDevicesCommandInput} for command's `input` shape.
+ * @see {@link ListDevicesCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListDevicesCommand extends $Command<ListDevicesCommandInput, ListDevicesCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: ListDevicesCommandInput;
+    constructor(input: ListDevicesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDevicesCommandInput, ListDevicesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListGroupsCommand.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 { ListGroupsRequest, ListGroupsResponse } from "../models/models_0";
+export interface ListGroupsCommandInput extends ListGroupsRequest {
+}
+export interface ListGroupsCommandOutput extends ListGroupsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists the groups associated with a user pool.</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, ListGroupsCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, ListGroupsCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new ListGroupsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListGroupsCommandInput} for command's `input` shape.
+ * @see {@link ListGroupsCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListGroupsCommand extends $Command<ListGroupsCommandInput, ListGroupsCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: ListGroupsCommandInput;
+    constructor(input: ListGroupsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListGroupsCommandInput, ListGroupsCommandOutput>;
+    private serialize;
+    private deserialize;
+}