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

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

@@ -6,33 +6,11 @@ export interface SetRiskConfigurationCommandInput extends SetRiskConfigurationRe
 }
 export interface SetRiskConfigurationCommandOutput extends SetRiskConfigurationResponse, __MetadataBearer {
 }
-/**
- * <p>Configures actions on detected risks. To delete the risk configuration for
- *                 <code>UserPoolId</code> or <code>ClientId</code>, pass null values for all four
- *             configuration types.</p>
- *         <p>To enable Amazon Cognito advanced security features, update the user pool to include
- *             the <code>UserPoolAddOns</code> key<code>AdvancedSecurityMode</code>.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CognitoIdentityProviderClient, SetRiskConfigurationCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, SetRiskConfigurationCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new SetRiskConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetRiskConfigurationCommandInput} for command's `input` shape.
- * @see {@link SetRiskConfigurationCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SetRiskConfigurationCommand extends $Command<SetRiskConfigurationCommandInput, SetRiskConfigurationCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: SetRiskConfigurationCommandInput;
     constructor(input: SetRiskConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetRiskConfigurationCommandInput, SetRiskConfigurationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,40 +6,11 @@ export interface SetUICustomizationCommandInput extends SetUICustomizationReques
 }
 export interface SetUICustomizationCommandOutput extends SetUICustomizationResponse, __MetadataBearer {
 }
-/**
- * <p>Sets the UI customization information for a user pool's built-in app UI.</p>
- *         <p>You can specify app UI customization settings for a single client (with a specific
- *                 <code>clientId</code>) or for all clients (by setting the <code>clientId</code> to
- *                 <code>ALL</code>). If you specify <code>ALL</code>, the default configuration will
- *             be used for every client that has no UI customization set previously. If you specify UI
- *             customization settings for a particular client, it will no longer fall back to the
- *                 <code>ALL</code> configuration. </p>
- *         <note>
- *             <p>To use this API, your user pool must have a domain associated with it. Otherwise,
- *                 there is no place to host the app's pages, and the service will throw an
- *                 error.</p>
- *         </note>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CognitoIdentityProviderClient, SetUICustomizationCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, SetUICustomizationCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new SetUICustomizationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetUICustomizationCommandInput} for command's `input` shape.
- * @see {@link SetUICustomizationCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SetUICustomizationCommand extends $Command<SetUICustomizationCommandInput, SetUICustomizationCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: SetUICustomizationCommandInput;
     constructor(input: SetUICustomizationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetUICustomizationCommandInput, SetUICustomizationCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,37 +6,11 @@ export interface SetUserMFAPreferenceCommandInput extends SetUserMFAPreferenceRe
 }
 export interface SetUserMFAPreferenceCommandOutput extends SetUserMFAPreferenceResponse, __MetadataBearer {
 }
-/**
- * <p>Set the user's multi-factor authentication (MFA) method preference, including which
- *             MFA factors are enabled and if any are preferred. Only one factor can be set as
- *             preferred. The preferred MFA factor will be used to authenticate a user if multiple
- *             factors are enabled. If multiple options are enabled and no preference is set, a
- *             challenge to choose an MFA option will be returned during sign in. If an MFA type is
- *             enabled for a user, the user will be prompted for MFA during all sign in attempts,
- *             unless device tracking is turned on and the device has been trusted. If you would like
- *             MFA to be applied selectively based on the assessed risk level of sign in attempts,
- *             disable MFA for users and turn on Adaptive Authentication for the user pool.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CognitoIdentityProviderClient, SetUserMFAPreferenceCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, SetUserMFAPreferenceCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new SetUserMFAPreferenceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SetUserMFAPreferenceCommandInput} for command's `input` shape.
- * @see {@link SetUserMFAPreferenceCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SetUserMFAPreferenceCommand extends $Command<SetUserMFAPreferenceCommandInput, SetUserMFAPreferenceCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: SetUserMFAPreferenceCommandInput;
     constructor(input: SetUserMFAPreferenceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetUserMFAPreferenceCommandInput, SetUserMFAPreferenceCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,47 +6,11 @@ export interface SignUpCommandInput extends SignUpRequest {
 }
 export interface SignUpCommandOutput extends SignUpResponse, __MetadataBearer {
 }
-/**
- * <p>Registers the user in the specified user pool and creates a user name, password, and
- *             user attributes.</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, SignUpCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, SignUpCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new SignUpCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link SignUpCommandInput} for command's `input` shape.
- * @see {@link SignUpCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class SignUpCommand extends $Command<SignUpCommandInput, SignUpCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: SignUpCommandInput;
     constructor(input: SignUpCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SignUpCommandInput, SignUpCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

@@ -6,42 +6,11 @@ export interface TagResourceCommandInput extends TagResourceRequest {
 }
 export interface TagResourceCommandOutput extends TagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Assigns a set of tags to an Amazon Cognito user pool. A tag is a label that you can
- *             use to categorize and manage user pools in different ways, such as by purpose, owner,
- *             environment, or other criteria.</p>
- *         <p>Each tag consists of a key and value, both of which you define. A key is a general
- *             category for more specific values. For example, if you have two versions of a user pool,
- *             one for testing and another for production, you might assign an <code>Environment</code>
- *             tag key to both user pools. The value of this key might be <code>Test</code> for one
- *             user pool and <code>Production</code> for the other.</p>
- *         <p>Tags are useful for cost tracking and access control. You can activate your tags so
- *             that they appear on the Billing and Cost Management console, where you can track the
- *             costs associated with your user pools. In an IAM policy, you can constrain permissions
- *             for user pools based on specific tags or tag values.</p>
- *         <p>You can use this action up to 5 times per second, per account. A user pool can have as
- *             many as 50 tags.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CognitoIdentityProviderClient, TagResourceCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, TagResourceCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new TagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link TagResourceCommandInput} for command's `input` shape.
- * @see {@link TagResourceCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface UntagResourceCommandInput extends UntagResourceRequest {
 }
 export interface UntagResourceCommandOutput extends UntagResourceResponse, __MetadataBearer {
 }
-/**
- * <p>Removes the specified tags from an Amazon Cognito user pool. You can use this action
- *             up to 5 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, UntagResourceCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, UntagResourceCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new UntagResourceCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UntagResourceCommandInput} for command's `input` shape.
- * @see {@link UntagResourceCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,31 +6,11 @@ export interface UpdateAuthEventFeedbackCommandInput extends UpdateAuthEventFeed
 }
 export interface UpdateAuthEventFeedbackCommandOutput extends UpdateAuthEventFeedbackResponse, __MetadataBearer {
 }
-/**
- * <p>Provides the feedback for an authentication event whether it was from a valid user or
- *             not. This feedback is used for improving the risk evaluation decision for the user pool
- *             as part of Amazon Cognito advanced security.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CognitoIdentityProviderClient, UpdateAuthEventFeedbackCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, UpdateAuthEventFeedbackCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new UpdateAuthEventFeedbackCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateAuthEventFeedbackCommandInput} for command's `input` shape.
- * @see {@link UpdateAuthEventFeedbackCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateAuthEventFeedbackCommand extends $Command<UpdateAuthEventFeedbackCommandInput, UpdateAuthEventFeedbackCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: UpdateAuthEventFeedbackCommandInput;
     constructor(input: UpdateAuthEventFeedbackCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAuthEventFeedbackCommandInput, UpdateAuthEventFeedbackCommandOutput>;
     private serialize;
     private deserialize;

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

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

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

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

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

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

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

@@ -6,33 +6,11 @@ export interface UpdateResourceServerCommandInput extends UpdateResourceServerRe
 }
 export interface UpdateResourceServerCommandOutput extends UpdateResourceServerResponse, __MetadataBearer {
 }
-/**
- * <p>Updates the name and scopes of resource server. All other fields are read-only.</p>
- *         <important>
- *             <p>If you don't provide a value for an attribute, it will be set to the default
- *                 value.</p>
- *         </important>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { CognitoIdentityProviderClient, UpdateResourceServerCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, UpdateResourceServerCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new UpdateResourceServerCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateResourceServerCommandInput} for command's `input` shape.
- * @see {@link UpdateResourceServerCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateResourceServerCommand extends $Command<UpdateResourceServerCommandInput, UpdateResourceServerCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: UpdateResourceServerCommandInput;
     constructor(input: UpdateResourceServerCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateResourceServerCommandInput, UpdateResourceServerCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,46 +6,11 @@ export interface UpdateUserAttributesCommandInput extends UpdateUserAttributesRe
 }
 export interface UpdateUserAttributesCommandOutput extends UpdateUserAttributesResponse, __MetadataBearer {
 }
-/**
- * <p>Allows a user to update a specific attribute (one at a time).</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, UpdateUserAttributesCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
- * // const { CognitoIdentityProviderClient, UpdateUserAttributesCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
- * const client = new CognitoIdentityProviderClient(config);
- * const command = new UpdateUserAttributesCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateUserAttributesCommandInput} for command's `input` shape.
- * @see {@link UpdateUserAttributesCommandOutput} for command's `response` shape.
- * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateUserAttributesCommand extends $Command<UpdateUserAttributesCommandInput, UpdateUserAttributesCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
     readonly input: UpdateUserAttributesCommandInput;
     constructor(input: UpdateUserAttributesCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateUserAttributesCommandInput, UpdateUserAttributesCommandOutput>;
     private serialize;
     private deserialize;