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

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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { SetUserSettingsRequest, SetUserSettingsResponse } from "../models/models_0";
+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/commands/SignUpCommand.d.ts

@@ -0,0 +1,53 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { SignUpRequest, SignUpResponse } from "../models/models_0";
+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/commands/StartUserImportJobCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { StartUserImportJobRequest } from "../models/models_0";
+import { StartUserImportJobResponse } from "../models/models_1";
+export interface StartUserImportJobCommandInput extends StartUserImportJobRequest {
+}
+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/commands/StopUserImportJobCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { StopUserImportJobRequest, StopUserImportJobResponse } from "../models/models_1";
+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/commands/TagResourceCommand.d.ts

@@ -0,0 +1,48 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { TagResourceRequest, TagResourceResponse } from "../models/models_1";
+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/commands/UntagResourceCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { UntagResourceRequest, UntagResourceResponse } from "../models/models_1";
+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/commands/UpdateAuthEventFeedbackCommand.d.ts

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { UpdateAuthEventFeedbackRequest, UpdateAuthEventFeedbackResponse } from "../models/models_1";
+export interface UpdateAuthEventFeedbackCommandInput extends UpdateAuthEventFeedbackRequest {
+}
+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/commands/UpdateDeviceStatusCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { UpdateDeviceStatusRequest, UpdateDeviceStatusResponse } from "../models/models_1";
+export interface UpdateDeviceStatusCommandInput extends UpdateDeviceStatusRequest {
+}
+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/commands/UpdateGroupCommand.d.ts

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { UpdateGroupRequest, UpdateGroupResponse } from "../models/models_1";
+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/commands/UpdateIdentityProviderCommand.d.ts

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { UpdateIdentityProviderRequest, UpdateIdentityProviderResponse } from "../models/models_1";
+export interface UpdateIdentityProviderCommandInput extends UpdateIdentityProviderRequest {
+}
+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/commands/UpdateResourceServerCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { UpdateResourceServerRequest, UpdateResourceServerResponse } from "../models/models_1";
+export interface UpdateResourceServerCommandInput extends UpdateResourceServerRequest {
+}
+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/commands/UpdateUserAttributesCommand.d.ts

@@ -0,0 +1,52 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { UpdateUserAttributesRequest, UpdateUserAttributesResponse } from "../models/models_1";
+export interface UpdateUserAttributesCommandInput extends UpdateUserAttributesRequest {
+}
+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;
+}

package/dist-types/commands/UpdateUserPoolClientCommand.d.ts

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { UpdateUserPoolClientRequest, UpdateUserPoolClientResponse } from "../models/models_1";
+export interface UpdateUserPoolClientCommandInput extends UpdateUserPoolClientRequest {
+}
+export interface UpdateUserPoolClientCommandOutput extends UpdateUserPoolClientResponse, __MetadataBearer {
+}
+/**
+ * <p>Updates the specified user pool app client with the specified attributes. You can get
+ *             a list of the current user pool app client settings using <a href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_DescribeUserPoolClient.html">DescribeUserPoolClient</a>.</p>
+ *         <important>
+ *             <p>If you don't provide a value for an attribute, it will be set to the default
+ *                 value.</p>
+ *         </important>
+ *         <p>You can also use this operation to enable token revocation for user pool clients. For more information
+ *         about revoking tokens, see <a href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_RevokeToken.html">RevokeToken</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CognitoIdentityProviderClient, UpdateUserPoolClientCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, UpdateUserPoolClientCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new UpdateUserPoolClientCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateUserPoolClientCommandInput} for command's `input` shape.
+ * @see {@link UpdateUserPoolClientCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateUserPoolClientCommand extends $Command<UpdateUserPoolClientCommandInput, UpdateUserPoolClientCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: UpdateUserPoolClientCommandInput;
+    constructor(input: UpdateUserPoolClientCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateUserPoolClientCommandInput, UpdateUserPoolClientCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateUserPoolCommand.d.ts

@@ -0,0 +1,54 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CognitoIdentityProviderClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CognitoIdentityProviderClient";
+import { UpdateUserPoolRequest, UpdateUserPoolResponse } from "../models/models_1";
+export interface UpdateUserPoolCommandInput extends UpdateUserPoolRequest {
+}
+export interface UpdateUserPoolCommandOutput extends UpdateUserPoolResponse, __MetadataBearer {
+}
+/**
+ * <p>Updates the specified user pool with the specified attributes. You can get a list of
+ *             the current user pool settings using <a href="https://docs.aws.amazon.com/cognito-user-identity-pools/latest/APIReference/API_DescribeUserPool.html">DescribeUserPool</a>. If you don't provide a value for an attribute, it will be set to the default
+ *             value.</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, UpdateUserPoolCommand } from "@aws-sdk/client-cognito-identity-provider"; // ES Modules import
+ * // const { CognitoIdentityProviderClient, UpdateUserPoolCommand } = require("@aws-sdk/client-cognito-identity-provider"); // CommonJS import
+ * const client = new CognitoIdentityProviderClient(config);
+ * const command = new UpdateUserPoolCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateUserPoolCommandInput} for command's `input` shape.
+ * @see {@link UpdateUserPoolCommandOutput} for command's `response` shape.
+ * @see {@link CognitoIdentityProviderClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateUserPoolCommand extends $Command<UpdateUserPoolCommandInput, UpdateUserPoolCommandOutput, CognitoIdentityProviderClientResolvedConfig> {
+    readonly input: UpdateUserPoolCommandInput;
+    constructor(input: UpdateUserPoolCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CognitoIdentityProviderClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateUserPoolCommandInput, UpdateUserPoolCommandOutput>;
+    private serialize;
+    private deserialize;
+}