@aws-sdk/client-cognito-identity-provider 3.35.0 → 3.38.0

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

@@ -6,38 +6,11 @@ export interface AssociateSoftwareTokenCommandInput extends AssociateSoftwareTok
 }
 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

@@ -6,29 +6,11 @@ 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

@@ -6,30 +6,11 @@ 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

@@ -6,29 +6,11 @@ export interface ConfirmForgotPasswordCommandInput extends ConfirmForgotPassword
 }
 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

@@ -6,30 +6,11 @@ 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

@@ -6,30 +6,11 @@ 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

@@ -6,29 +6,11 @@ export interface CreateIdentityProviderCommandInput extends CreateIdentityProvid
 }
 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

@@ -6,29 +6,11 @@ export interface CreateResourceServerCommandInput extends CreateResourceServerRe
 }
 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

@@ -6,29 +6,11 @@ export interface CreateUserImportJobCommandInput extends CreateUserImportJobRequ
 }
 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

@@ -6,31 +6,11 @@ export interface CreateUserPoolClientCommandInput extends CreateUserPoolClientRe
 }
 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;

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

@@ -6,47 +6,11 @@ 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

@@ -6,29 +6,11 @@ export interface CreateUserPoolDomainCommandInput extends CreateUserPoolDomainRe
 }
 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

@@ -6,30 +6,11 @@ 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

@@ -6,29 +6,11 @@ export interface DeleteIdentityProviderCommandInput extends DeleteIdentityProvid
 }
 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

@@ -6,29 +6,11 @@ export interface DeleteResourceServerCommandInput extends DeleteResourceServerRe
 }
 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

@@ -6,29 +6,11 @@ export interface DeleteUserAttributesCommandInput extends DeleteUserAttributesRe
 }
 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

@@ -6,29 +6,11 @@ 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

@@ -6,29 +6,11 @@ export interface DeleteUserPoolClientCommandInput extends DeleteUserPoolClientRe
 }
 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;