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

package/dist-types/ts3.4/commands/AdminSetUserSettingsCommand.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 { AdminSetUserSettingsRequest, AdminSetUserSettingsResponse } from "../models/models_0";
+export interface AdminSetUserSettingsCommandInput extends AdminSetUserSettingsRequest {
+}
+export interface AdminSetUserSettingsCommandOutput extends AdminSetUserSettingsResponse, __MetadataBearer {
+}
+/**
+ * <p>
+ *             <i>This action is no longer supported.</i> You can use it to configure
+ *             only SMS MFA. You can't use it to configure TOTP software token MFA. To configure either
+ *             type of MFA, use <a href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_AdminSetUserMFAPreference.html">AdminSetUserMFAPreference</a> instead.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, AdminSetUserSettingsCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, AdminSetUserSettingsCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new AdminSetUserSettingsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AdminSetUserSettingsCommandInput} for command's `input` shape.
+ * @see {@link AdminSetUserSettingsCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AdminSetUserSettingsCommand extends $Command<AdminSetUserSettingsCommandInput, AdminSetUserSettingsCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: AdminSetUserSettingsCommandInput;
+    constructor(input: AdminSetUserSettingsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AdminSetUserSettingsCommandInput, AdminSetUserSettingsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/AdminUpdateAuthEventFeedbackCommand.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 { AdminUpdateAuthEventFeedbackRequest, AdminUpdateAuthEventFeedbackResponse } from "../models/models_0";
+export interface AdminUpdateAuthEventFeedbackCommandInput extends AdminUpdateAuthEventFeedbackRequest {
+}
+export interface AdminUpdateAuthEventFeedbackCommandOutput extends AdminUpdateAuthEventFeedbackResponse, __MetadataBearer {
+}
+/**
+ * <p>Provides feedback for an authentication event as to whether it was from a valid user.
+ *             This feedback is used for improving the risk evaluation decision for the user pool 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, AdminUpdateAuthEventFeedbackCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, AdminUpdateAuthEventFeedbackCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new AdminUpdateAuthEventFeedbackCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AdminUpdateAuthEventFeedbackCommandInput} for command's `input` shape.
+ * @see {@link AdminUpdateAuthEventFeedbackCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AdminUpdateAuthEventFeedbackCommand extends $Command<AdminUpdateAuthEventFeedbackCommandInput, AdminUpdateAuthEventFeedbackCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: AdminUpdateAuthEventFeedbackCommandInput;
+    constructor(input: AdminUpdateAuthEventFeedbackCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AdminUpdateAuthEventFeedbackCommandInput, AdminUpdateAuthEventFeedbackCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/ts3.4/commands/AdminUpdateUserAttributesCommand.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 { AdminUpdateUserAttributesRequest, AdminUpdateUserAttributesResponse } from "../models/models_0";
+export interface AdminUpdateUserAttributesCommandInput extends AdminUpdateUserAttributesRequest {
+}
+export interface AdminUpdateUserAttributesCommandOutput extends AdminUpdateUserAttributesResponse, __MetadataBearer {
+}
+/**
+ * <p>Updates the specified user's attributes, including developer attributes, as an
+ *             administrator. Works on any user.</p>
+ *         <p>For custom attributes, you must prepend the <code>custom:</code> prefix to the
+ *             attribute name.</p>
+ *         <p>In addition to updating user attributes, this API can also be used to mark phone and
+ *             email as verified.</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, AdminUpdateUserAttributesCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, AdminUpdateUserAttributesCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new AdminUpdateUserAttributesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AdminUpdateUserAttributesCommandInput} for command's `input` shape.
+ * @see {@link AdminUpdateUserAttributesCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AdminUpdateUserAttributesCommand extends $Command<AdminUpdateUserAttributesCommandInput, AdminUpdateUserAttributesCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: AdminUpdateUserAttributesCommandInput;
+    constructor(input: AdminUpdateUserAttributesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AdminUpdateUserAttributesCommandInput, AdminUpdateUserAttributesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

package/dist-types/ts3.4/commands/AssociateSoftwareTokenCommand.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 { AssociateSoftwareTokenRequest, AssociateSoftwareTokenResponse } from "../models/models_0";
+export interface AssociateSoftwareTokenCommandInput extends AssociateSoftwareTokenRequest {
+}
+export interface AssociateSoftwareTokenCommandOutput extends AssociateSoftwareTokenResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns a unique generated shared secret key code for the user account. The request
+ *             takes an access token or a session string, but not both.</p>
+ *         <note>
+ *             <p>Calling AssociateSoftwareToken immediately disassociates the existing software
+ *                 token from the user account. If the user doesn't subsequently verify the software
+ *                 token, their account is essentially set up to authenticate without MFA. If MFA
+ *                 config is set to Optional at the user pool level, the user can then login without
+ *                 MFA. However, if MFA is set to Required for the user pool, the user will be asked to
+ *                 setup a new software token MFA during sign in.</p>
+ *         </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, AssociateSoftwareTokenCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, AssociateSoftwareTokenCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new AssociateSoftwareTokenCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link AssociateSoftwareTokenCommandInput} for command's `input` shape.
+ * @see {@link AssociateSoftwareTokenCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class AssociateSoftwareTokenCommand extends $Command<AssociateSoftwareTokenCommandInput, AssociateSoftwareTokenCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: AssociateSoftwareTokenCommandInput;
+    constructor(input: AssociateSoftwareTokenCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<AssociateSoftwareTokenCommandInput, AssociateSoftwareTokenCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

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

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

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

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

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

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

package/dist-types/ts3.4/commands/CreateUserPoolClientCommand.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 { CreateUserPoolClientRequest, CreateUserPoolClientResponse } from "../models/models_0";
+export interface CreateUserPoolClientCommandInput extends CreateUserPoolClientRequest {
+}
+export interface CreateUserPoolClientCommandOutput extends CreateUserPoolClientResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates the user pool client.</p>
+ *         <p>When you create a new user pool client, token revocation is automatically enabled. For more information
+ *             about revoking tokens, see <a href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RevokeToken.html">RevokeToken</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, CreateUserPoolClientCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, CreateUserPoolClientCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new CreateUserPoolClientCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateUserPoolClientCommandInput} for command's `input` shape.
+ * @see {@link CreateUserPoolClientCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateUserPoolClientCommand extends $Command<CreateUserPoolClientCommandInput, CreateUserPoolClientCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: CreateUserPoolClientCommandInput;
+    constructor(input: CreateUserPoolClientCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateUserPoolClientCommandInput, CreateUserPoolClientCommandOutput>;
+    private serialize;
+    private deserialize;
+}