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

package/dist-types/ts3.4/commands/AdminEnableUserCommand.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 { AdminEnableUserRequest, AdminEnableUserResponse } from "../models/models_0";
+export interface AdminEnableUserCommandInput extends AdminEnableUserRequest {
+}
+export interface AdminEnableUserCommandOutput extends AdminEnableUserResponse, __MetadataBearer {
+}
+/**
+ * <p>Enables the specified user as an administrator. Works on any user.</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, AdminEnableUserCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, AdminEnableUserCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new AdminEnableUserCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AdminEnableUserCommandInput} for command's `input` shape.
+ * @see {@link AdminEnableUserCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AdminEnableUserCommand extends $Command<AdminEnableUserCommandInput, AdminEnableUserCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: AdminEnableUserCommandInput;
+    constructor(input: AdminEnableUserCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AdminEnableUserCommandInput, AdminEnableUserCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

package/dist-types/ts3.4/commands/AdminGetUserCommand.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 { AdminGetUserRequest, AdminGetUserResponse } from "../models/models_0";
+export interface AdminGetUserCommandInput extends AdminGetUserRequest {
+}
+export interface AdminGetUserCommandOutput extends AdminGetUserResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets the specified user by user name in a user pool as an administrator. Works on any
+ *             user.</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, AdminGetUserCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, AdminGetUserCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new AdminGetUserCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AdminGetUserCommandInput} for command's `input` shape.
+ * @see {@link AdminGetUserCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AdminGetUserCommand extends $Command<AdminGetUserCommandInput, AdminGetUserCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: AdminGetUserCommandInput;
+    constructor(input: AdminGetUserCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AdminGetUserCommandInput, AdminGetUserCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,55 @@
+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 { AdminInitiateAuthRequest, AdminInitiateAuthResponse } from "../models/models_0";
+export interface AdminInitiateAuthCommandInput extends AdminInitiateAuthRequest {
+}
+export interface AdminInitiateAuthCommandOutput extends AdminInitiateAuthResponse, __MetadataBearer {
+}
+/**
+ * <p>Initiates the authentication flow, as an administrator.</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>
+ *
+ *         <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, AdminInitiateAuthCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, AdminInitiateAuthCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new AdminInitiateAuthCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AdminInitiateAuthCommandInput} for command's `input` shape.
+ * @see {@link AdminInitiateAuthCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AdminInitiateAuthCommand extends $Command<AdminInitiateAuthCommandInput, AdminInitiateAuthCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: AdminInitiateAuthCommandInput;
+    constructor(input: AdminInitiateAuthCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AdminInitiateAuthCommandInput, AdminInitiateAuthCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,55 @@
+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 { AdminLinkProviderForUserRequest, AdminLinkProviderForUserResponse } from "../models/models_0";
+export interface AdminLinkProviderForUserCommandInput extends AdminLinkProviderForUserRequest {
+}
+export interface AdminLinkProviderForUserCommandOutput extends AdminLinkProviderForUserResponse, __MetadataBearer {
+}
+/**
+ * <p>Links an existing user account in a user pool (<code>DestinationUser</code>) to an
+ *             identity from an external identity provider (<code>SourceUser</code>) based on a
+ *             specified attribute name and value from the external identity provider. This allows you
+ *             to create a link from the existing user account to an external federated user identity
+ *             that has not yet been used to sign in, so that the federated user identity can be used
+ *             to sign in as the existing user account. </p>
+ *         <p> For example, if there is an existing user with a username and password, this API
+ *             links that user to a federated user identity, so that when the federated user identity
+ *             is used, the user signs in as the existing user account. </p>
+ *         <note>
+ *             <p>The maximum number of federated identities linked to a user is 5.</p>
+ *         </note>
+ *         <important>
+ *             <p>Because this API allows a user with an external federated identity to sign in as
+ *                 an existing user in the user pool, it is critical that it only be used with external
+ *                 identity providers and provider attributes that have been trusted by the application
+ *                 owner.</p>
+ *         </important>
+ *
+ *         <p>This action is enabled only for admin access and requires developer
+ *             credentials.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, AdminLinkProviderForUserCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, AdminLinkProviderForUserCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new AdminLinkProviderForUserCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AdminLinkProviderForUserCommandInput} for command's `input` shape.
+ * @see {@link AdminLinkProviderForUserCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AdminLinkProviderForUserCommand extends $Command<AdminLinkProviderForUserCommandInput, AdminLinkProviderForUserCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: AdminLinkProviderForUserCommandInput;
+    constructor(input: AdminLinkProviderForUserCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AdminLinkProviderForUserCommandInput, AdminLinkProviderForUserCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

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

@@ -0,0 +1,64 @@
+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 { AdminResetUserPasswordRequest, AdminResetUserPasswordResponse } from "../models/models_0";
+export interface AdminResetUserPasswordCommandInput extends AdminResetUserPasswordRequest {
+}
+export interface AdminResetUserPasswordCommandOutput extends AdminResetUserPasswordResponse, __MetadataBearer {
+}
+/**
+ * <p>Resets the specified user's password in a user pool as an administrator. Works on any
+ *             user.</p>
+ *         <p>When a developer calls this API, the current password is invalidated, so it must be
+ *             changed. If a user tries to sign in after the API is called, the app will get a
+ *             PasswordResetRequiredException exception back and should direct the user down the flow
+ *             to reset the password, which is the same as the forgot password flow. In addition, if
+ *             the user pool has phone verification selected and a verified phone number exists for the
+ *             user, or if email verification is selected and a verified email exists for the user,
+ *             calling this API will also result in sending a message to the end user with the code to
+ *             change their password.</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>
+ *
+ *         <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, AdminResetUserPasswordCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, AdminResetUserPasswordCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new AdminResetUserPasswordCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AdminResetUserPasswordCommandInput} for command's `input` shape.
+ * @see {@link AdminResetUserPasswordCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AdminResetUserPasswordCommand extends $Command<AdminResetUserPasswordCommandInput, AdminResetUserPasswordCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: AdminResetUserPasswordCommandInput;
+    constructor(input: AdminResetUserPasswordCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AdminResetUserPasswordCommandInput, AdminResetUserPasswordCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,54 @@
+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 { AdminRespondToAuthChallengeRequest, AdminRespondToAuthChallengeResponse } from "../models/models_0";
+export interface AdminRespondToAuthChallengeCommandInput extends AdminRespondToAuthChallengeRequest {
+}
+export interface AdminRespondToAuthChallengeCommandOutput extends AdminRespondToAuthChallengeResponse, __MetadataBearer {
+}
+/**
+ * <p>Responds to an authentication challenge, as an administrator.</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>
+ *
+ *         <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, AdminRespondToAuthChallengeCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, AdminRespondToAuthChallengeCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new AdminRespondToAuthChallengeCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AdminRespondToAuthChallengeCommandInput} for command's `input` shape.
+ * @see {@link AdminRespondToAuthChallengeCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AdminRespondToAuthChallengeCommand extends $Command<AdminRespondToAuthChallengeCommandInput, AdminRespondToAuthChallengeCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: AdminRespondToAuthChallengeCommandInput;
+    constructor(input: AdminRespondToAuthChallengeCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AdminRespondToAuthChallengeCommandInput, AdminRespondToAuthChallengeCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

@@ -0,0 +1,44 @@
+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 { AdminSetUserPasswordRequest, AdminSetUserPasswordResponse } from "../models/models_0";
+export interface AdminSetUserPasswordCommandInput extends AdminSetUserPasswordRequest {
+}
+export interface AdminSetUserPasswordCommandOutput extends AdminSetUserPasswordResponse, __MetadataBearer {
+}
+/**
+ * <p>Sets the specified user's password in a user pool as an administrator. Works on any
+ *             user. </p>
+ *         <p>The password can be temporary or permanent. If it is temporary, the user status will
+ *             be placed into the <code>FORCE_CHANGE_PASSWORD</code> state. When the user next tries to
+ *             sign in, the InitiateAuth/AdminInitiateAuth response will contain the
+ *                 <code>NEW_PASSWORD_REQUIRED</code> challenge. If the user does not sign in before it
+ *             expires, the user will not be able to sign in and their password will need to be reset
+ *             by an administrator. </p>
+ *         <p>Once the user has set a new password, or the password is permanent, the user status
+ *             will be set to <code>Confirmed</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, AdminSetUserPasswordCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, AdminSetUserPasswordCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new AdminSetUserPasswordCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AdminSetUserPasswordCommandInput} for command's `input` shape.
+ * @see {@link AdminSetUserPasswordCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AdminSetUserPasswordCommand extends $Command<AdminSetUserPasswordCommandInput, AdminSetUserPasswordCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: AdminSetUserPasswordCommandInput;
+    constructor(input: AdminSetUserPasswordCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AdminSetUserPasswordCommandInput, AdminSetUserPasswordCommandOutput>;
+    private serialize;
+    private deserialize;
+}