@aws-sdk/client-cognito-identity-provider 3.193.0 → 3.196.0

package/dist-es/commands/UpdateUserPoolCommand.js

@@ -1,3 +1,4 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 import { Command as $Command } from "@aws-sdk/smithy-client";
@@ -8,8 +9,17 @@ export class UpdateUserPoolCommand extends $Command {
         super();
         this.input = input;
     }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateUserPoolCommand.getEndpointParameterInstructions()));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;

package/dist-es/commands/UpdateUserPoolDomainCommand.js

@@ -1,3 +1,4 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 import { Command as $Command } from "@aws-sdk/smithy-client";
@@ -8,8 +9,17 @@ export class UpdateUserPoolDomainCommand extends $Command {
         super();
         this.input = input;
     }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateUserPoolDomainCommand.getEndpointParameterInstructions()));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;

package/dist-es/commands/VerifySoftwareTokenCommand.js

@@ -1,3 +1,4 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { getAwsAuthPlugin } from "@aws-sdk/middleware-signing";
 import { Command as $Command } from "@aws-sdk/smithy-client";
@@ -8,8 +9,17 @@ export class VerifySoftwareTokenCommand extends $Command {
         super();
         this.input = input;
     }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, VerifySoftwareTokenCommand.getEndpointParameterInstructions()));
         this.middlewareStack.use(getAwsAuthPlugin(configuration));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;

package/dist-es/commands/VerifyUserAttributeCommand.js

@@ -1,3 +1,4 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { VerifyUserAttributeRequestFilterSensitiveLog, VerifyUserAttributeResponseFilterSensitiveLog, } from "../models/models_1";
@@ -7,8 +8,17 @@ export class VerifyUserAttributeCommand extends $Command {
         super();
         this.input = input;
     }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
     resolveMiddleware(clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, VerifyUserAttributeCommand.getEndpointParameterInstructions()));
         const stack = clientStack.concat(this.middlewareStack);
         const { logger } = configuration;
         const clientName = "CognitoIdentityProviderClient";

package/dist-es/endpoint/EndpointParameters.js

@@ -0,0 +1,8 @@
+export const resolveClientEndpointParameters = (options) => {
+    return {
+        ...options,
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "cognito-idp",
+    };
+};

package/dist-es/endpoint/endpointResolver.js

@@ -0,0 +1,8 @@
+import { resolveEndpoint } from "@aws-sdk/util-endpoints";
+import { ruleSet } from "./ruleset";
+export const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return resolveEndpoint(ruleSet, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    });
+};

package/dist-es/endpoint/ruleset.js

@@ -0,0 +1,315 @@
+export const ruleSet = {
+    version: "1.0",
+    parameters: {
+        Region: {
+            builtIn: "AWS::Region",
+            required: false,
+            documentation: "The AWS region used to dispatch the request.",
+            type: "String",
+        },
+        UseDualStack: {
+            builtIn: "AWS::UseDualStack",
+            required: true,
+            default: false,
+            documentation: "When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.",
+            type: "Boolean",
+        },
+        UseFIPS: {
+            builtIn: "AWS::UseFIPS",
+            required: true,
+            default: false,
+            documentation: "When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.",
+            type: "Boolean",
+        },
+        Endpoint: {
+            builtIn: "SDK::Endpoint",
+            required: false,
+            documentation: "Override the endpoint used to send this request",
+            type: "String",
+        },
+    },
+    rules: [
+        {
+            conditions: [
+                {
+                    fn: "aws.partition",
+                    argv: [
+                        {
+                            ref: "Region",
+                        },
+                    ],
+                    assign: "PartitionResult",
+                },
+            ],
+            type: "tree",
+            rules: [
+                {
+                    conditions: [
+                        {
+                            fn: "isSet",
+                            argv: [
+                                {
+                                    ref: "Endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            fn: "parseURL",
+                            argv: [
+                                {
+                                    ref: "Endpoint",
+                                },
+                            ],
+                            assign: "url",
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        {
+                                            ref: "UseFIPS",
+                                        },
+                                        true,
+                                    ],
+                                },
+                            ],
+                            error: "Invalid Configuration: FIPS and custom endpoint are not supported",
+                            type: "error",
+                        },
+                        {
+                            conditions: [],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [
+                                        {
+                                            fn: "booleanEquals",
+                                            argv: [
+                                                {
+                                                    ref: "UseDualStack",
+                                                },
+                                                true,
+                                            ],
+                                        },
+                                    ],
+                                    error: "Invalid Configuration: Dualstack and custom endpoint are not supported",
+                                    type: "error",
+                                },
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: {
+                                            ref: "Endpoint",
+                                        },
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseFIPS",
+                                },
+                                true,
+                            ],
+                        },
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseDualStack",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsFIPS",
+                                            ],
+                                        },
+                                    ],
+                                },
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsDualStack",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://cognito-idp-fips.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "FIPS and DualStack are enabled, but this partition does not support one or both",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseFIPS",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsFIPS",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    type: "tree",
+                                    rules: [
+                                        {
+                                            conditions: [],
+                                            endpoint: {
+                                                url: "https://cognito-idp-fips.{Region}.{PartitionResult#dnsSuffix}",
+                                                properties: {},
+                                                headers: {},
+                                            },
+                                            type: "endpoint",
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "FIPS is enabled but this partition does not support FIPS",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [
+                        {
+                            fn: "booleanEquals",
+                            argv: [
+                                {
+                                    ref: "UseDualStack",
+                                },
+                                true,
+                            ],
+                        },
+                    ],
+                    type: "tree",
+                    rules: [
+                        {
+                            conditions: [
+                                {
+                                    fn: "booleanEquals",
+                                    argv: [
+                                        true,
+                                        {
+                                            fn: "getAttr",
+                                            argv: [
+                                                {
+                                                    ref: "PartitionResult",
+                                                },
+                                                "supportsDualStack",
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                            type: "tree",
+                            rules: [
+                                {
+                                    conditions: [],
+                                    endpoint: {
+                                        url: "https://cognito-idp.{Region}.{PartitionResult#dualStackDnsSuffix}",
+                                        properties: {},
+                                        headers: {},
+                                    },
+                                    type: "endpoint",
+                                },
+                            ],
+                        },
+                        {
+                            conditions: [],
+                            error: "DualStack is enabled but this partition does not support DualStack",
+                            type: "error",
+                        },
+                    ],
+                },
+                {
+                    conditions: [],
+                    endpoint: {
+                        url: "https://cognito-idp.{Region}.{PartitionResult#dnsSuffix}",
+                        properties: {},
+                        headers: {},
+                    },
+                    type: "endpoint",
+                },
+            ],
+        },
+    ],
+};

package/dist-es/models/models_0.js

@@ -542,6 +542,11 @@ export var UserImportJobStatusType;
     UserImportJobStatusType["Stopping"] = "Stopping";
     UserImportJobStatusType["Succeeded"] = "Succeeded";
 })(UserImportJobStatusType || (UserImportJobStatusType = {}));
+export var DeletionProtectionType;
+(function (DeletionProtectionType) {
+    DeletionProtectionType["ACTIVE"] = "ACTIVE";
+    DeletionProtectionType["INACTIVE"] = "INACTIVE";
+})(DeletionProtectionType || (DeletionProtectionType = {}));
 export var EmailSendingAccountType;
 (function (EmailSendingAccountType) {
     EmailSendingAccountType["COGNITO_DEFAULT"] = "COGNITO_DEFAULT";
@@ -1505,16 +1510,3 @@ export const SetUserSettingsRequestFilterSensitiveLog = (obj) => ({
 export const SetUserSettingsResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
-export const SignUpRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ClientId && { ClientId: SENSITIVE_STRING }),
-    ...(obj.SecretHash && { SecretHash: SENSITIVE_STRING }),
-    ...(obj.Username && { Username: SENSITIVE_STRING }),
-    ...(obj.Password && { Password: SENSITIVE_STRING }),
-    ...(obj.UserAttributes && {
-        UserAttributes: obj.UserAttributes.map((item) => AttributeTypeFilterSensitiveLog(item)),
-    }),
-    ...(obj.ValidationData && {
-        ValidationData: obj.ValidationData.map((item) => AttributeTypeFilterSensitiveLog(item)),
-    }),
-});

package/dist-es/models/models_1.js

@@ -18,6 +18,19 @@ export var VerifySoftwareTokenResponseType;
     VerifySoftwareTokenResponseType["ERROR"] = "ERROR";
     VerifySoftwareTokenResponseType["SUCCESS"] = "SUCCESS";
 })(VerifySoftwareTokenResponseType || (VerifySoftwareTokenResponseType = {}));
+export const SignUpRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ClientId && { ClientId: SENSITIVE_STRING }),
+    ...(obj.SecretHash && { SecretHash: SENSITIVE_STRING }),
+    ...(obj.Username && { Username: SENSITIVE_STRING }),
+    ...(obj.Password && { Password: SENSITIVE_STRING }),
+    ...(obj.UserAttributes && {
+        UserAttributes: obj.UserAttributes.map((item) => AttributeTypeFilterSensitiveLog(item)),
+    }),
+    ...(obj.ValidationData && {
+        ValidationData: obj.ValidationData.map((item) => AttributeTypeFilterSensitiveLog(item)),
+    }),
+});
 export const SignUpResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });

package/dist-es/protocols/Aws_json1_1.js

@@ -3128,6 +3128,9 @@ const deserializeAws_json1_1DeleteIdentityProviderCommandError = async (output,
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "ConcurrentModificationException":
+        case "com.amazonaws.cognitoidentityprovider#ConcurrentModificationException":
+            throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
         case "InternalErrorException":
         case "com.amazonaws.cognitoidentityprovider#InternalErrorException":
             throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
@@ -3371,6 +3374,9 @@ const deserializeAws_json1_1DeleteUserPoolClientCommandError = async (output, co
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "ConcurrentModificationException":
+        case "com.amazonaws.cognitoidentityprovider#ConcurrentModificationException":
+            throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
         case "InternalErrorException":
         case "com.amazonaws.cognitoidentityprovider#InternalErrorException":
             throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
@@ -5855,6 +5861,9 @@ const deserializeAws_json1_1UpdateIdentityProviderCommandError = async (output,
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "ConcurrentModificationException":
+        case "com.amazonaws.cognitoidentityprovider#ConcurrentModificationException":
+            throw await deserializeAws_json1_1ConcurrentModificationExceptionResponse(parsedOutput, context);
         case "InternalErrorException":
         case "com.amazonaws.cognitoidentityprovider#InternalErrorException":
             throw await deserializeAws_json1_1InternalErrorExceptionResponse(parsedOutput, context);
@@ -7277,6 +7286,7 @@ const serializeAws_json1_1CreateUserPoolRequest = (input, context) => {
         ...(input.AutoVerifiedAttributes != null && {
             AutoVerifiedAttributes: serializeAws_json1_1VerifiedAttributesListType(input.AutoVerifiedAttributes, context),
         }),
+        ...(input.DeletionProtection != null && { DeletionProtection: input.DeletionProtection }),
         ...(input.DeviceConfiguration != null && {
             DeviceConfiguration: serializeAws_json1_1DeviceConfigurationType(input.DeviceConfiguration, context),
         }),
@@ -8176,6 +8186,7 @@ const serializeAws_json1_1UpdateUserPoolRequest = (input, context) => {
         ...(input.AutoVerifiedAttributes != null && {
             AutoVerifiedAttributes: serializeAws_json1_1VerifiedAttributesListType(input.AutoVerifiedAttributes, context),
         }),
+        ...(input.DeletionProtection != null && { DeletionProtection: input.DeletionProtection }),
         ...(input.DeviceConfiguration != null && {
             DeviceConfiguration: serializeAws_json1_1DeviceConfigurationType(input.DeviceConfiguration, context),
         }),
@@ -9963,6 +9974,7 @@ const deserializeAws_json1_1UserPoolType = (output, context) => {
             ? __expectNonNull(__parseEpochTimestamp(__expectNumber(output.CreationDate)))
             : undefined,
         CustomDomain: __expectString(output.CustomDomain),
+        DeletionProtection: __expectString(output.DeletionProtection),
         DeviceConfiguration: output.DeviceConfiguration != null
             ? deserializeAws_json1_1DeviceConfigurationType(output.DeviceConfiguration, context)
             : undefined,

package/dist-es/runtimeConfig.shared.js

@@ -1,10 +1,10 @@
 import { parseUrl } from "@aws-sdk/url-parser";
-import { defaultRegionInfoProvider } from "./endpoints";
+import { defaultEndpointResolver } from "./endpoint/endpointResolver";
 export const getRuntimeConfig = (config) => ({
     apiVersion: "2016-04-18",
     disableHostPrefix: config?.disableHostPrefix ?? false,
+    endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
     logger: config?.logger ?? {},
-    regionInfoProvider: config?.regionInfoProvider ?? defaultRegionInfoProvider,
     serviceId: config?.serviceId ?? "Cognito Identity Provider",
     urlParser: config?.urlParser ?? parseUrl,
 });

package/dist-types/CognitoIdentityProvider.d.ts

@@ -216,8 +216,9 @@ export declare class CognitoIdentityProvider extends CognitoIdentityProviderClie
     adminDisableProviderForUser(args: AdminDisableProviderForUserCommandInput, cb: (err: any, data?: AdminDisableProviderForUserCommandOutput) => void): void;
     adminDisableProviderForUser(args: AdminDisableProviderForUserCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: AdminDisableProviderForUserCommandOutput) => void): void;
     /**
-     * <p>Disables the specified user.</p>
-     *         <p>Calling this action requires developer credentials.</p>
+     * <p>Deactivates a user and revokes all access tokens for the user. A deactivated user can't sign in,
+     *             but still appears in the responses to <code>GetUser</code> and <code>ListUsers</code> API requests.</p>
+     *         <p>You must make this API request with Amazon Web Services credentials that have <code>cognito-idp:AdminDisableUser</code> permissions.</p>
      */
     adminDisableUser(args: AdminDisableUserCommandInput, options?: __HttpHandlerOptions): Promise<AdminDisableUserCommandOutput>;
     adminDisableUser(args: AdminDisableUserCommandInput, cb: (err: any, data?: AdminDisableUserCommandOutput) => void): void;
@@ -749,7 +750,9 @@ export declare class CognitoIdentityProvider extends CognitoIdentityProviderClie
     getIdentityProviderByIdentifier(args: GetIdentityProviderByIdentifierCommandInput, cb: (err: any, data?: GetIdentityProviderByIdentifierCommandOutput) => void): void;
     getIdentityProviderByIdentifier(args: GetIdentityProviderByIdentifierCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetIdentityProviderByIdentifierCommandOutput) => void): void;
     /**
-     * <p>This method takes a user pool ID, and returns the signing certificate.</p>
+     * <p>This method takes a user pool ID, and returns the signing certificate. The issued certificate is valid for 10 years from the date of issue.</p>
+     *         <p>Amazon Cognito issues and assigns a new signing certificate annually. This process returns a new value in the response to <code>GetSigningCertificate</code>,
+     *             but doesn't invalidate the original certificate.</p>
      */
     getSigningCertificate(args: GetSigningCertificateCommandInput, options?: __HttpHandlerOptions): Promise<GetSigningCertificateCommandOutput>;
     getSigningCertificate(args: GetSigningCertificateCommandInput, cb: (err: any, data?: GetSigningCertificateCommandOutput) => void): void;
@@ -804,10 +807,8 @@ export declare class CognitoIdentityProvider extends CognitoIdentityProviderClie
     getUserPoolMfaConfig(args: GetUserPoolMfaConfigCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetUserPoolMfaConfigCommandOutput) => void): void;
     /**
      * <p>Signs out users from all devices. It also invalidates all refresh tokens that Amazon Cognito
-     *             has issued to a user. The user's current access and ID tokens remain valid until their
-     *             expiry. By default, access and ID tokens expire one hour after Amazon Cognito issues them. A user
-     *             can still use a hosted UI cookie to retrieve new tokens for the duration of the cookie
-     *             validity period of 1 hour.</p>
+     *             has issued to a user. A user can still use a hosted UI cookie to retrieve new tokens
+     *             for the duration of the 1-hour cookie validity period.</p>
      */
     globalSignOut(args: GlobalSignOutCommandInput, options?: __HttpHandlerOptions): Promise<GlobalSignOutCommandOutput>;
     globalSignOut(args: GlobalSignOutCommandInput, cb: (err: any, data?: GlobalSignOutCommandOutput) => void): void;
@@ -952,9 +953,9 @@ export declare class CognitoIdentityProvider extends CognitoIdentityProviderClie
     respondToAuthChallenge(args: RespondToAuthChallengeCommandInput, cb: (err: any, data?: RespondToAuthChallengeCommandOutput) => void): void;
     respondToAuthChallenge(args: RespondToAuthChallengeCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: RespondToAuthChallengeCommandOutput) => void): void;
     /**
-     * <p>Revokes all of the access tokens generated by the specified refresh token. After the
-     *             token is revoked, you can't use the revoked token to access Amazon Cognito authenticated
-     *             APIs.</p>
+     * <p>Revokes all of the access tokens generated by, and at the same time as, the specified
+     *             refresh token. After a token is revoked, you can't use the revoked token to access
+     *             Amazon Cognito user APIs, or to authorize access to your resource server.</p>
      */
     revokeToken(args: RevokeTokenCommandInput, options?: __HttpHandlerOptions): Promise<RevokeTokenCommandOutput>;
     revokeToken(args: RevokeTokenCommandInput, cb: (err: any, data?: RevokeTokenCommandOutput) => void): void;