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

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

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

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface DescribeUserPoolClientCommandInput extends DescribeUserPoolClie
 }
 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

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

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

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

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

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

@@ -6,53 +6,11 @@ export interface ForgotPasswordCommandInput extends ForgotPasswordRequest {
 }
 export interface ForgotPasswordCommandOutput extends ForgotPasswordResponse, __MetadataBearer {
 }
-/**
- * <p>Calling this API causes a message to be sent to the end user with a confirmation code
- *             that is required to change the user's password. For the <code>Username</code> parameter,
- *             you can use the username or user alias. The method used to send the confirmation code is
- *             sent according to the specified AccountRecoverySetting. For more information, see <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/how-to-recover-a-user-account.html">Recovering
- *                 User Accounts</a> in the <i>Amazon Cognito Developer Guide</i>. If
- *             neither a verified phone number nor a verified email exists, an
- *                 <code>InvalidParameterException</code> is thrown. To use the confirmation code for
- *             resetting the password, call <a href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_ConfirmForgotPassword.html">ConfirmForgotPassword</a>.</p>
- *
- *         <note>
- *             <p>This action might generate an SMS text message. Starting June 1, 2021, U.S.
- *                 telecom carriers require that you register an origination phone number before you can
- *                 send SMS messages to U.S. phone numbers. If you use SMS text messages in Amazon Cognito,
- *                 you must register a phone number with <a href="https://console.aws.amazon.com/pinpoint/home/">Amazon Pinpoint</a>.
- *                 Cognito  will use the the registered number automatically. Otherwise, Cognito users that must
- *                 receive SMS messages might be unable to sign up, activate their accounts, or sign
- *                 in.</p>
- *             <p>If you have never used SMS text messages with Amazon Cognito or any other Amazon Web Service, Amazon SNS might place your account in SMS sandbox. In <i>
- *                   <a href="https://docs.aws.amazon.com/sns/latest/dg/sns-sms-sandbox.html">sandbox
- *                     mode</a>
- *                </i>, you’ll have limitations, such as sending messages
- *                 to only verified phone numbers. After testing in the sandbox environment, you can
- *                 move out of the SMS sandbox and into production. For more information, see <a href="https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools-sms-userpool-settings.html"> SMS message settings for Cognito User Pools</a> in the <i>Amazon
- *                         Cognito Developer Guide</i>. </p>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CognitoIdentityProviderClient, ForgotPasswordCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, ForgotPasswordCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new ForgotPasswordCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ForgotPasswordCommandInput} for command's `input` shape.
- * @see {@link ForgotPasswordCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ForgotPasswordCommand extends $Command<ForgotPasswordCommandInput, ForgotPasswordCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: ForgotPasswordCommandInput;
     constructor(input: ForgotPasswordCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ForgotPasswordCommandInput, ForgotPasswordCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,30 +6,11 @@ export interface GetGroupCommandInput extends GetGroupRequest {
 }
 export interface GetGroupCommandOutput extends GetGroupResponse, __MetadataBearer {
 }
-/**
- * <p>Gets a group.</p>
- *         <p>Calling this action requires developer credentials.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CognitoIdentityProviderClient, GetGroupCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, GetGroupCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new GetGroupCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetGroupCommandInput} for command's `input` shape.
- * @see {@link GetGroupCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetGroupCommand extends $Command<GetGroupCommandInput, GetGroupCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: GetGroupCommandInput;
     constructor(input: GetGroupCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetGroupCommandInput, GetGroupCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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