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

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

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

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

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

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

@@ -6,31 +6,11 @@ export interface GlobalSignOutCommandInput extends GlobalSignOutRequest {
 }
 export interface GlobalSignOutCommandOutput extends GlobalSignOutResponse, __MetadataBearer {
 }
-/**
- * <p>Signs out users from all devices. It also invalidates all refresh tokens issued to a
- *             user. The user's current access and Id tokens remain valid until their expiry. Access
- *             and Id tokens expire one hour after they are issued.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CognitoIdentityProviderClient, GlobalSignOutCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, GlobalSignOutCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new GlobalSignOutCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GlobalSignOutCommandInput} for command's `input` shape.
- * @see {@link GlobalSignOutCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GlobalSignOutCommand extends $Command<GlobalSignOutCommandInput, GlobalSignOutCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: GlobalSignOutCommandInput;
     constructor(input: GlobalSignOutCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GlobalSignOutCommandInput, GlobalSignOutCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,46 +6,11 @@ export interface InitiateAuthCommandInput extends InitiateAuthRequest {
 }
 export interface InitiateAuthCommandOutput extends InitiateAuthResponse, __MetadataBearer {
 }
-/**
- * <p>Initiates the authentication flow.</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, InitiateAuthCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, InitiateAuthCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new InitiateAuthCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link InitiateAuthCommandInput} for command's `input` shape.
- * @see {@link InitiateAuthCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class InitiateAuthCommand extends $Command<InitiateAuthCommandInput, InitiateAuthCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: InitiateAuthCommandInput;
     constructor(input: InitiateAuthCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<InitiateAuthCommandInput, InitiateAuthCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

@@ -6,30 +6,11 @@ export interface ListGroupsCommandInput extends ListGroupsRequest {
 }
 export interface ListGroupsCommandOutput extends ListGroupsResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the groups associated with a 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, ListGroupsCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, ListGroupsCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new ListGroupsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListGroupsCommandInput} for command's `input` shape.
- * @see {@link ListGroupsCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListGroupsCommand extends $Command<ListGroupsCommandInput, ListGroupsCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: ListGroupsCommandInput;
     constructor(input: ListGroupsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListGroupsCommandInput, ListGroupsCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,32 +6,11 @@ export interface ListTagsForResourceCommandInput extends ListTagsForResourceRequ
 }
 export interface ListTagsForResourceCommandOutput extends ListTagsForResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Lists the tags that are assigned to an Amazon Cognito user pool.</p>
- *         <p>A tag is a label that you can apply to user pools to categorize and manage them in
- *             different ways, such as by purpose, owner, environment, or other criteria.</p>
- *         <p>You can use this action up to 10 times per second, per account.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CognitoIdentityProviderClient, ListTagsForResourceCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, ListTagsForResourceCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new ListTagsForResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
- * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: ListTagsForResourceCommandInput;
     constructor(input: ListTagsForResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

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

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

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

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

@@ -6,47 +6,11 @@ export interface ResendConfirmationCodeCommandInput extends ResendConfirmationCo
 }
 export interface ResendConfirmationCodeCommandOutput extends ResendConfirmationCodeResponse, __MetadataBearer {
 }
-/**
- * <p>Resends the confirmation (for confirmation of registration) to a specific user in the
- *             user 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, ResendConfirmationCodeCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, ResendConfirmationCodeCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new ResendConfirmationCodeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ResendConfirmationCodeCommandInput} for command's `input` shape.
- * @see {@link ResendConfirmationCodeCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ResendConfirmationCodeCommand extends $Command<ResendConfirmationCodeCommandInput, ResendConfirmationCodeCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: ResendConfirmationCodeCommandInput;
     constructor(input: ResendConfirmationCodeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResendConfirmationCodeCommandInput, ResendConfirmationCodeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,46 +6,11 @@ export interface RespondToAuthChallengeCommandInput extends RespondToAuthChallen
 }
 export interface RespondToAuthChallengeCommandOutput extends RespondToAuthChallengeResponse, __MetadataBearer {
 }
-/**
- * <p>Responds to the authentication challenge.</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, RespondToAuthChallengeCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, RespondToAuthChallengeCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new RespondToAuthChallengeCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RespondToAuthChallengeCommandInput} for command's `input` shape.
- * @see {@link RespondToAuthChallengeCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RespondToAuthChallengeCommand extends $Command<RespondToAuthChallengeCommandInput, RespondToAuthChallengeCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: RespondToAuthChallengeCommandInput;
     constructor(input: RespondToAuthChallengeCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RespondToAuthChallengeCommandInput, RespondToAuthChallengeCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface RevokeTokenCommandInput extends RevokeTokenRequest {
 }
 export interface RevokeTokenCommandOutput extends RevokeTokenResponse, __MetadataBearer {
 }
-/**
- * <p>Revokes all of the access tokens generated by the specified refresh token. After the token is revoked, you can not
- *             use the revoked token to access Cognito authenticated APIs.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CognitoIdentityProviderClient, RevokeTokenCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, RevokeTokenCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new RevokeTokenCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RevokeTokenCommandInput} for command's `input` shape.
- * @see {@link RevokeTokenCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class RevokeTokenCommand extends $Command<RevokeTokenCommandInput, RevokeTokenCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: RevokeTokenCommandInput;
     constructor(input: RevokeTokenCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RevokeTokenCommandInput, RevokeTokenCommandOutput>;
     private serialize;
     private deserialize;