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

package/dist/types/ts3.4/commands/CreateUserPoolCommand.d.ts

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

package/dist/types/ts3.4/commands/CreateUserPoolDomainCommand.d.ts

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

package/dist/types/ts3.4/commands/DeleteGroupCommand.d.ts

@@ -1,36 +0,0 @@
-import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
-import { DeleteGroupRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteGroupCommandInput extends DeleteGroupRequest {
-}
-export interface DeleteGroupCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes 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, DeleteGroupCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, DeleteGroupCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new DeleteGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteGroupCommandInput} for command's `input` shape.
- * @see {@link DeleteGroupCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteGroupCommand extends $Command<DeleteGroupCommandInput, DeleteGroupCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
-    readonly input: DeleteGroupCommandInput;
-    constructor(input: DeleteGroupCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteGroupCommandInput, DeleteGroupCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteIdentityProviderCommand.d.ts

@@ -1,35 +0,0 @@
-import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
-import { DeleteIdentityProviderRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface DeleteIdentityProviderCommandInput extends DeleteIdentityProviderRequest {
-}
-export interface DeleteIdentityProviderCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Deletes 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, DeleteIdentityProviderCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, DeleteIdentityProviderCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new DeleteIdentityProviderCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link DeleteIdentityProviderCommandInput} for command's `input` shape.
- * @see {@link DeleteIdentityProviderCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class DeleteIdentityProviderCommand extends $Command<DeleteIdentityProviderCommandInput, DeleteIdentityProviderCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
-    readonly input: DeleteIdentityProviderCommandInput;
-    constructor(input: DeleteIdentityProviderCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteIdentityProviderCommandInput, DeleteIdentityProviderCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/DeleteResourceServerCommand.d.ts

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

package/dist/types/ts3.4/commands/DeleteUserAttributesCommand.d.ts

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

package/dist/types/ts3.4/commands/DeleteUserCommand.d.ts

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

package/dist/types/ts3.4/commands/DeleteUserPoolClientCommand.d.ts

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

package/dist/types/ts3.4/commands/DeleteUserPoolCommand.d.ts

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

package/dist/types/ts3.4/commands/DeleteUserPoolDomainCommand.d.ts

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

package/dist/types/ts3.4/commands/DescribeIdentityProviderCommand.d.ts

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

package/dist/types/ts3.4/commands/DescribeResourceServerCommand.d.ts

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

package/dist/types/ts3.4/commands/DescribeRiskConfigurationCommand.d.ts

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

package/dist/types/ts3.4/commands/DescribeUserImportJobCommand.d.ts

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

package/dist/types/ts3.4/commands/DescribeUserPoolClientCommand.d.ts

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

package/dist/types/ts3.4/commands/DescribeUserPoolCommand.d.ts

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

package/dist/types/ts3.4/commands/DescribeUserPoolDomainCommand.d.ts

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