const { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
const { NoAuthSigner, getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
const { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, makeBuilder, createAggregatedClient } = require("@smithy/core/client");
const { Command: $Command } = require("@smithy/core/client");
exports.$Command = $Command;
exports.__Client = Client;
const { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require("@smithy/core/config");
const { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
const { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
const { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
const { TypeRegistry, getSchemaSerdePlugin } = require("@smithy/core/schema");
const { resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require("@aws-sdk/core/httpAuthSchemes");
const { defaultProvider } = require("@aws-sdk/credential-provider-node");
const { toUtf8, fromUtf8, toBase64, fromBase64, calculateBodyLength } = require("@smithy/core/serde");
const { streamCollector, NodeHttpHandler } = require("@smithy/node-http-handler");
const { AwsJson1_1Protocol } = require("@aws-sdk/core/protocols");
const { Sha256 } = require("@smithy/core/checksum");

const defaultCognitoIdentityProviderHttpAuthSchemeParametersProvider = async (config, context, input) => {
    return {
        operation: getSmithyContext(context).operation,
        region: await normalizeProvider(config.region)() || (() => {
            throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
        })(),
    };
};
function createAwsAuthSigv4HttpAuthOption(authParameters) {
    return {
        schemeId: "aws.auth#sigv4",
        signingProperties: {
            name: "cognito-idp",
            region: authParameters.region,
        },
        propertiesExtractor: (config, context) => ({
            signingProperties: {
                config,
                context,
            },
        }),
    };
}
function createSmithyApiNoAuthHttpAuthOption(authParameters) {
    return {
        schemeId: "smithy.api#noAuth",
    };
}
const defaultCognitoIdentityProviderHttpAuthSchemeProvider = (authParameters) => {
    const options = [];
    switch (authParameters.operation) {
        case "AssociateSoftwareToken":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "ChangePassword":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "CompleteWebAuthnRegistration":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "ConfirmDevice":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "ConfirmForgotPassword":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "ConfirmSignUp":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "DeleteUser":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "DeleteUserAttributes":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "DeleteWebAuthnCredential":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "ForgetDevice":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "ForgotPassword":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "GetDevice":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "GetTokensFromRefreshToken":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "GetUser":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "GetUserAttributeVerificationCode":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "GetUserAuthFactors":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "GlobalSignOut":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "InitiateAuth":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "ListDevices":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "ListWebAuthnCredentials":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "ResendConfirmationCode":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "RespondToAuthChallenge":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "RevokeToken":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "SetUserMFAPreference":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "SetUserSettings":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "SignUp":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "StartWebAuthnRegistration":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "UpdateAuthEventFeedback":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "UpdateDeviceStatus":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "UpdateUserAttributes":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "VerifySoftwareToken":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        case "VerifyUserAttribute":
            {
                options.push(createSmithyApiNoAuthHttpAuthOption());
                break;
            }
        default: {
            options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
        }
    }
    return options;
};
const resolveHttpAuthSchemeConfig = (config) => {
    const config_0 = resolveAwsSdkSigV4Config(config);
    return Object.assign(config_0, {
        authSchemePreference: normalizeProvider(config.authSchemePreference ?? []),
    });
};

const resolveClientEndpointParameters = (options) => {
    return Object.assign(options, {
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        defaultSigningName: "cognito-idp",
    });
};
const commonParams = {
    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
    Endpoint: { type: "builtInParams", name: "endpoint" },
    Region: { type: "builtInParams", name: "region" },
    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
};

var version = "3.1141.0";
var packageInfo = {
	version: version};

const m = "ref";
const a = -1, b = true, c = "isSet", d = "PartitionResult", e = "booleanEquals", f = "getAttr", g = "stringEquals", h = { [m]: "Endpoint" }, i = { [m]: d }, j = { [m]: "Region" }, k = {}, l = [j];
const _data = {
    conditions: [
        [c, [h]],
        [c, l],
        ["aws.partition", l, d],
        [e, [{ [m]: "UseFIPS" }, b]],
        [e, [{ fn: f, argv: [i, "supportsFIPS"] }, b]],
        [e, [{ [m]: "UseDualStack" }, b]],
        [e, [{ fn: f, argv: [i, "supportsDualStack"] }, b]],
        [g, [{ fn: f, argv: [i, "name"] }, "aws"]],
        [g, [j, "us-east-1"]],
        [g, [j, "us-east-2"]],
        [g, [j, "us-west-1"]],
        [g, [j, "us-west-2"]]
    ],
    results: [
        [a],
        [a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
        [a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
        [h, k],
        ["https://cognito-idp-fips.us-east-1.amazonaws.com", k],
        ["https://cognito-idp-fips.us-east-2.amazonaws.com", k],
        ["https://cognito-idp-fips.us-west-1.amazonaws.com", k],
        ["https://cognito-idp-fips.us-west-2.amazonaws.com", k],
        ["https://cognito-idp-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", k],
        [a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
        ["https://cognito-idp-fips.{Region}.{PartitionResult#dnsSuffix}", k],
        [a, "FIPS is enabled but this partition does not support FIPS"],
        ["https://cognito-idp.{Region}.amazonaws.com", k],
        ["https://cognito-idp.{Region}.{PartitionResult#dualStackDnsSuffix}", k],
        [a, "DualStack is enabled but this partition does not support DualStack"],
        ["https://cognito-idp.{Region}.{PartitionResult#dnsSuffix}", k],
        [a, "Invalid Configuration: Missing Region"]
    ]
};
const root = 2;
const r = 100_000_000;
const nodes = new Int32Array([
    -1, 1, -1,
    0, 17, 3,
    1, 4, r + 16,
    2, 5, r + 16,
    3, 9, 6,
    5, 7, r + 15,
    6, 8, r + 14,
    7, r + 12, r + 13,
    4, 11, 10,
    5, r + 9, r + 11,
    5, 12, r + 10,
    6, 13, r + 9,
    8, r + 4, 14,
    9, r + 5, 15,
    10, r + 6, 16,
    11, r + 7, r + 8,
    3, r + 1, 18,
    5, r + 2, r + 3,
]);
const bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);

const cache = new EndpointCache({
    size: 50,
    params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"],
});
const defaultEndpointResolver = (endpointParams, context = {}) => {
    return cache.get(endpointParams, () => decideEndpoint(bdd, {
        endpointParams: endpointParams,
        logger: context.logger,
    }));
};
customEndpointFunctions.aws = awsEndpointFunctions;

class CognitoIdentityProviderServiceException extends ServiceException {
    constructor(options) {
        super(options);
        Object.setPrototypeOf(this, CognitoIdentityProviderServiceException.prototype);
    }
}

class AccessDeniedException extends CognitoIdentityProviderServiceException {
    name = "AccessDeniedException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "AccessDeniedException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, AccessDeniedException.prototype);
    }
}
class InternalErrorException extends CognitoIdentityProviderServiceException {
    name = "InternalErrorException";
    $fault = "server";
    constructor(opts) {
        super({
            name: "InternalErrorException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, InternalErrorException.prototype);
    }
}
class InvalidParameterException extends CognitoIdentityProviderServiceException {
    name = "InvalidParameterException";
    $fault = "client";
    reasonCode;
    constructor(opts) {
        super({
            name: "InvalidParameterException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidParameterException.prototype);
        this.reasonCode = opts.reasonCode;
    }
}
class NotAuthorizedException extends CognitoIdentityProviderServiceException {
    name = "NotAuthorizedException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "NotAuthorizedException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, NotAuthorizedException.prototype);
    }
}
class OperationNotEnabledException extends CognitoIdentityProviderServiceException {
    name = "OperationNotEnabledException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "OperationNotEnabledException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, OperationNotEnabledException.prototype);
    }
}
class ResourceNotFoundException extends CognitoIdentityProviderServiceException {
    name = "ResourceNotFoundException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "ResourceNotFoundException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
    }
}
class TooManyRequestsException extends CognitoIdentityProviderServiceException {
    name = "TooManyRequestsException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "TooManyRequestsException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, TooManyRequestsException.prototype);
    }
}
class UserImportInProgressException extends CognitoIdentityProviderServiceException {
    name = "UserImportInProgressException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "UserImportInProgressException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UserImportInProgressException.prototype);
    }
}
class InternalServerException extends CognitoIdentityProviderServiceException {
    name = "InternalServerException";
    $fault = "server";
    constructor(opts) {
        super({
            name: "InternalServerException",
            $fault: "server",
            ...opts,
        });
        Object.setPrototypeOf(this, InternalServerException.prototype);
    }
}
class LimitExceededException extends CognitoIdentityProviderServiceException {
    name = "LimitExceededException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "LimitExceededException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, LimitExceededException.prototype);
    }
}
class UserNotFoundException extends CognitoIdentityProviderServiceException {
    name = "UserNotFoundException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "UserNotFoundException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UserNotFoundException.prototype);
    }
}
class InvalidLambdaResponseException extends CognitoIdentityProviderServiceException {
    name = "InvalidLambdaResponseException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "InvalidLambdaResponseException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidLambdaResponseException.prototype);
    }
}
class TooManyFailedAttemptsException extends CognitoIdentityProviderServiceException {
    name = "TooManyFailedAttemptsException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "TooManyFailedAttemptsException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, TooManyFailedAttemptsException.prototype);
    }
}
class UnexpectedLambdaException extends CognitoIdentityProviderServiceException {
    name = "UnexpectedLambdaException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "UnexpectedLambdaException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UnexpectedLambdaException.prototype);
    }
}
class UserLambdaValidationException extends CognitoIdentityProviderServiceException {
    name = "UserLambdaValidationException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "UserLambdaValidationException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UserLambdaValidationException.prototype);
    }
}
class CodeDeliveryFailureException extends CognitoIdentityProviderServiceException {
    name = "CodeDeliveryFailureException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "CodeDeliveryFailureException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, CodeDeliveryFailureException.prototype);
    }
}
class InvalidPasswordException extends CognitoIdentityProviderServiceException {
    name = "InvalidPasswordException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "InvalidPasswordException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidPasswordException.prototype);
    }
}
class InvalidSmsRoleAccessPolicyException extends CognitoIdentityProviderServiceException {
    name = "InvalidSmsRoleAccessPolicyException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "InvalidSmsRoleAccessPolicyException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidSmsRoleAccessPolicyException.prototype);
    }
}
class InvalidSmsRoleTrustRelationshipException extends CognitoIdentityProviderServiceException {
    name = "InvalidSmsRoleTrustRelationshipException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "InvalidSmsRoleTrustRelationshipException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidSmsRoleTrustRelationshipException.prototype);
    }
}
class PreconditionNotMetException extends CognitoIdentityProviderServiceException {
    name = "PreconditionNotMetException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "PreconditionNotMetException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, PreconditionNotMetException.prototype);
    }
}
class UnsupportedUserStateException extends CognitoIdentityProviderServiceException {
    name = "UnsupportedUserStateException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "UnsupportedUserStateException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UnsupportedUserStateException.prototype);
    }
}
class UsernameExistsException extends CognitoIdentityProviderServiceException {
    name = "UsernameExistsException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "UsernameExistsException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UsernameExistsException.prototype);
    }
}
class UserNotConfirmedException extends CognitoIdentityProviderServiceException {
    name = "UserNotConfirmedException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "UserNotConfirmedException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UserNotConfirmedException.prototype);
    }
}
class AliasExistsException extends CognitoIdentityProviderServiceException {
    name = "AliasExistsException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "AliasExistsException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, AliasExistsException.prototype);
    }
}
class InvalidUserPoolConfigurationException extends CognitoIdentityProviderServiceException {
    name = "InvalidUserPoolConfigurationException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "InvalidUserPoolConfigurationException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidUserPoolConfigurationException.prototype);
    }
}
class InvalidEmailRoleAccessPolicyException extends CognitoIdentityProviderServiceException {
    name = "InvalidEmailRoleAccessPolicyException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "InvalidEmailRoleAccessPolicyException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidEmailRoleAccessPolicyException.prototype);
    }
}
class MFAMethodNotFoundException extends CognitoIdentityProviderServiceException {
    name = "MFAMethodNotFoundException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "MFAMethodNotFoundException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, MFAMethodNotFoundException.prototype);
    }
}
class PasswordResetRequiredException extends CognitoIdentityProviderServiceException {
    name = "PasswordResetRequiredException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "PasswordResetRequiredException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, PasswordResetRequiredException.prototype);
    }
}
class UnsupportedOperationException extends CognitoIdentityProviderServiceException {
    name = "UnsupportedOperationException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "UnsupportedOperationException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UnsupportedOperationException.prototype);
    }
}
class UserPoolAddOnNotEnabledException extends CognitoIdentityProviderServiceException {
    name = "UserPoolAddOnNotEnabledException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "UserPoolAddOnNotEnabledException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UserPoolAddOnNotEnabledException.prototype);
    }
}
class CodeMismatchException extends CognitoIdentityProviderServiceException {
    name = "CodeMismatchException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "CodeMismatchException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, CodeMismatchException.prototype);
    }
}
class ExpiredCodeException extends CognitoIdentityProviderServiceException {
    name = "ExpiredCodeException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "ExpiredCodeException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ExpiredCodeException.prototype);
    }
}
class PasswordHistoryPolicyViolationException extends CognitoIdentityProviderServiceException {
    name = "PasswordHistoryPolicyViolationException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "PasswordHistoryPolicyViolationException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, PasswordHistoryPolicyViolationException.prototype);
    }
}
class SoftwareTokenMFANotFoundException extends CognitoIdentityProviderServiceException {
    name = "SoftwareTokenMFANotFoundException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "SoftwareTokenMFANotFoundException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, SoftwareTokenMFANotFoundException.prototype);
    }
}
class ConcurrentModificationException extends CognitoIdentityProviderServiceException {
    name = "ConcurrentModificationException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "ConcurrentModificationException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ConcurrentModificationException.prototype);
    }
}
class ForbiddenException extends CognitoIdentityProviderServiceException {
    name = "ForbiddenException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "ForbiddenException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ForbiddenException.prototype);
    }
}
class WebAuthnChallengeNotFoundException extends CognitoIdentityProviderServiceException {
    name = "WebAuthnChallengeNotFoundException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "WebAuthnChallengeNotFoundException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, WebAuthnChallengeNotFoundException.prototype);
    }
}
class WebAuthnClientMismatchException extends CognitoIdentityProviderServiceException {
    name = "WebAuthnClientMismatchException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "WebAuthnClientMismatchException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, WebAuthnClientMismatchException.prototype);
    }
}
class WebAuthnCredentialNotSupportedException extends CognitoIdentityProviderServiceException {
    name = "WebAuthnCredentialNotSupportedException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "WebAuthnCredentialNotSupportedException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, WebAuthnCredentialNotSupportedException.prototype);
    }
}
class WebAuthnNotEnabledException extends CognitoIdentityProviderServiceException {
    name = "WebAuthnNotEnabledException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "WebAuthnNotEnabledException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, WebAuthnNotEnabledException.prototype);
    }
}
class WebAuthnOriginNotAllowedException extends CognitoIdentityProviderServiceException {
    name = "WebAuthnOriginNotAllowedException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "WebAuthnOriginNotAllowedException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, WebAuthnOriginNotAllowedException.prototype);
    }
}
class WebAuthnRelyingPartyMismatchException extends CognitoIdentityProviderServiceException {
    name = "WebAuthnRelyingPartyMismatchException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "WebAuthnRelyingPartyMismatchException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, WebAuthnRelyingPartyMismatchException.prototype);
    }
}
class DeviceKeyExistsException extends CognitoIdentityProviderServiceException {
    name = "DeviceKeyExistsException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "DeviceKeyExistsException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, DeviceKeyExistsException.prototype);
    }
}
class GroupExistsException extends CognitoIdentityProviderServiceException {
    name = "GroupExistsException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "GroupExistsException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, GroupExistsException.prototype);
    }
}
class DuplicateProviderException extends CognitoIdentityProviderServiceException {
    name = "DuplicateProviderException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "DuplicateProviderException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, DuplicateProviderException.prototype);
    }
}
class ManagedLoginBrandingExistsException extends CognitoIdentityProviderServiceException {
    name = "ManagedLoginBrandingExistsException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "ManagedLoginBrandingExistsException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ManagedLoginBrandingExistsException.prototype);
    }
}
class TermsExistsException extends CognitoIdentityProviderServiceException {
    name = "TermsExistsException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "TermsExistsException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, TermsExistsException.prototype);
    }
}
class FeatureUnavailableInTierException extends CognitoIdentityProviderServiceException {
    name = "FeatureUnavailableInTierException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "FeatureUnavailableInTierException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, FeatureUnavailableInTierException.prototype);
    }
}
class TierChangeNotAllowedException extends CognitoIdentityProviderServiceException {
    name = "TierChangeNotAllowedException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "TierChangeNotAllowedException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, TierChangeNotAllowedException.prototype);
    }
}
class UserPoolTaggingException extends CognitoIdentityProviderServiceException {
    name = "UserPoolTaggingException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "UserPoolTaggingException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UserPoolTaggingException.prototype);
    }
}
class InvalidOAuthFlowException extends CognitoIdentityProviderServiceException {
    name = "InvalidOAuthFlowException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "InvalidOAuthFlowException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, InvalidOAuthFlowException.prototype);
    }
}
class ScopeDoesNotExistException extends CognitoIdentityProviderServiceException {
    name = "ScopeDoesNotExistException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "ScopeDoesNotExistException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ScopeDoesNotExistException.prototype);
    }
}
class UnsupportedIdentityProviderException extends CognitoIdentityProviderServiceException {
    name = "UnsupportedIdentityProviderException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "UnsupportedIdentityProviderException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UnsupportedIdentityProviderException.prototype);
    }
}
class RefreshTokenReuseException extends CognitoIdentityProviderServiceException {
    name = "RefreshTokenReuseException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "RefreshTokenReuseException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, RefreshTokenReuseException.prototype);
    }
}
class UnauthorizedException extends CognitoIdentityProviderServiceException {
    name = "UnauthorizedException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "UnauthorizedException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UnauthorizedException.prototype);
    }
}
class UnsupportedTokenTypeException extends CognitoIdentityProviderServiceException {
    name = "UnsupportedTokenTypeException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "UnsupportedTokenTypeException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, UnsupportedTokenTypeException.prototype);
    }
}
class WebAuthnConfigurationMissingException extends CognitoIdentityProviderServiceException {
    name = "WebAuthnConfigurationMissingException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "WebAuthnConfigurationMissingException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, WebAuthnConfigurationMissingException.prototype);
    }
}
class ServiceQuotaExceededException extends CognitoIdentityProviderServiceException {
    name = "ServiceQuotaExceededException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "ServiceQuotaExceededException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
    }
}
class EnableSoftwareTokenMFAException extends CognitoIdentityProviderServiceException {
    name = "EnableSoftwareTokenMFAException";
    $fault = "client";
    constructor(opts) {
        super({
            name: "EnableSoftwareTokenMFAException",
            $fault: "client",
            ...opts,
        });
        Object.setPrototypeOf(this, EnableSoftwareTokenMFAException.prototype);
    }
}

const _A = "Actions";
const _AA = "ApplicationArn";
const _AACUO = "AllowAdminCreateUserOnly";
const _AAUTG = "AdminAddUserToGroup";
const _AAUTGR = "AdminAddUserToGroupRequest";
const _AAl = "AliasAttributes";
const _AAu = "AuthenticatorAttachment";
const _AC = "AvailableChallenges";
const _ACA = "AddCustomAttributes";
const _ACAR = "AddCustomAttributesRequest";
const _ACARd = "AddCustomAttributesResponse";
const _ACSU = "AdminConfirmSignUp";
const _ACSUR = "AdminConfirmSignUpRequest";
const _ACSURd = "AdminConfirmSignUpResponse";
const _ACT = "AnalyticsConfigurationType";
const _ACU = "AdminCreateUser";
const _ACUC = "AdminCreateUserConfig";
const _ACUCT = "AdminCreateUserConfigType";
const _ACUR = "AdminCreateUserRequest";
const _ACURd = "AdminCreateUserResponse";
const _ACn = "AnalyticsConfiguration";
const _ADE = "AccessDeniedException";
const _ADPFU = "AdminDisableProviderForUser";
const _ADPFUR = "AdminDisableProviderForUserRequest";
const _ADPFURd = "AdminDisableProviderForUserResponse";
const _ADST = "AdminDeleteSoftwareToken";
const _ADSTR = "AdminDeleteSoftwareTokenRequest";
const _ADSTRd = "AdminDeleteSoftwareTokenResponse";
const _ADT = "AttributeDataType";
const _ADU = "AdminDeleteUser";
const _ADUA = "AdminDeleteUserAttributes";
const _ADUAR = "AdminDeleteUserAttributesRequest";
const _ADUARd = "AdminDeleteUserAttributesResponse";
const _ADUR = "AdminDeleteUserRequest";
const _ADURd = "AdminDisableUserRequest";
const _ADURdm = "AdminDisableUserResponse";
const _ADUd = "AdminDisableUser";
const _AE = "AuthEvents";
const _AEE = "AliasExistsException";
const _AEI = "AnalyticsEndpointId";
const _AET = "AuthEventType";
const _AETu = "AuthEventsType";
const _AEU = "AdminEnableUser";
const _AEUR = "AdminEnableUserRequest";
const _AEURd = "AdminEnableUserResponse";
const _AF = "AuthFlow";
const _AFAF = "AllowedFirstAuthFactors";
const _AFD = "AdminForgetDevice";
const _AFDR = "AdminForgetDeviceRequest";
const _AGD = "AdminGetDevice";
const _AGDR = "AdminGetDeviceRequest";
const _AGDRd = "AdminGetDeviceResponse";
const _AGU = "AdminGetUser";
const _AGUAF = "AdminGetUserAuthFactors";
const _AGUAFR = "AdminGetUserAuthFactorsRequest";
const _AGUAFRd = "AdminGetUserAuthFactorsResponse";
const _AGUR = "AdminGetUserRequest";
const _AGURd = "AdminGetUserResponse";
const _AI = "ApplicationId";
const _AIA = "AdminInitiateAuth";
const _AIAR = "AdminInitiateAuthRequest";
const _AIARd = "AdminInitiateAuthResponse";
const _ALD = "AdminListDevices";
const _ALDR = "AdminListDevicesRequest";
const _ALDRd = "AdminListDevicesResponse";
const _ALGFU = "AdminListGroupsForUser";
const _ALGFUR = "AdminListGroupsForUserRequest";
const _ALGFURd = "AdminListGroupsForUserResponse";
const _ALPFU = "AdminLinkProviderForUser";
const _ALPFUR = "AdminLinkProviderForUserRequest";
const _ALPFURd = "AdminLinkProviderForUserResponse";
const _ALT = "AssetListType";
const _ALTt = "AttributeListType";
const _ALUAE = "AdminListUserAuthEvents";
const _ALUAER = "AdminListUserAuthEventsRequest";
const _ALUAERd = "AdminListUserAuthEventsResponse";
const _AM = "AnalyticsMetadata";
const _AMT = "AnalyticsMetadataType";
const _AMt = "AttributeMapping";
const _AN = "AttributeName";
const _AOAF = "AllowedOAuthFlows";
const _AOAFUPC = "AllowedOAuthFlowsUserPoolClient";
const _AOAS = "AllowedOAuthScopes";
const _AP = "AuthParameters";
const _APT = "AuthParametersType";
const _AR = "AuthenticationResult";
const _ARS = "AccountRecoverySetting";
const _ARST = "AccountRecoverySettingType";
const _ART = "AuthenticationResultType";
const _ARTAC = "AdminRespondToAuthChallenge";
const _ARTACR = "AdminRespondToAuthChallengeRequest";
const _ARTACRd = "AdminRespondToAuthChallengeResponse";
const _ARUFG = "AdminRemoveUserFromGroup";
const _ARUFGR = "AdminRemoveUserFromGroupRequest";
const _ARUP = "AdminResetUserPassword";
const _ARUPR = "AdminResetUserPasswordRequest";
const _ARUPRd = "AdminResetUserPasswordResponse";
const _ARVBU = "AttributesRequireVerificationBeforeUpdate";
const _ASAF = "AdvancedSecurityAdditionalFlows";
const _ASAFT = "AdvancedSecurityAdditionalFlowsType";
const _ASM = "AdvancedSecurityMode";
const _AST = "AssociateSoftwareToken";
const _ASTR = "AssociateSoftwareTokenRequest";
const _ASTRs = "AssociateSoftwareTokenResponse";
const _ASUMFAP = "AdminSetUserMFAPreference";
const _ASUMFAPR = "AdminSetUserMFAPreferenceRequest";
const _ASUMFAPRd = "AdminSetUserMFAPreferenceResponse";
const _ASUP = "AdminSetUserPassword";
const _ASUPR = "AdminSetUserPasswordRequest";
const _ASUPRd = "AdminSetUserPasswordResponse";
const _ASUS = "AdminSetUserSettings";
const _ASUSR = "AdminSetUserSettingsRequest";
const _ASUSRd = "AdminSetUserSettingsResponse";
const _ASV = "AuthSessionValidity";
const _AT = "AssetType";
const _ATAT = "AccountTakeoverActionsType";
const _ATATc = "AccountTakeoverActionType";
const _ATG = "AttributesToGet";
const _ATRC = "AccountTakeoverRiskConfiguration";
const _ATRCT = "AccountTakeoverRiskConfigurationType";
const _ATV = "AccessTokenValidity";
const _ATc = "AccessToken";
const _ATt = "AttributeType";
const _ATu = "AuthenticatorTransports";
const _AUAEF = "AdminUpdateAuthEventFeedback";
const _AUAEFR = "AdminUpdateAuthEventFeedbackRequest";
const _AUAEFRd = "AdminUpdateAuthEventFeedbackResponse";
const _AUDS = "AdminUpdateDeviceStatus";
const _AUDSR = "AdminUpdateDeviceStatusRequest";
const _AUDSRd = "AdminUpdateDeviceStatusResponse";
const _AUGSO = "AdminUserGlobalSignOut";
const _AUGSOR = "AdminUserGlobalSignOutRequest";
const _AUGSORd = "AdminUserGlobalSignOutResponse";
const _AUPCS = "AddUserPoolClientSecret";
const _AUPCSR = "AddUserPoolClientSecretRequest";
const _AUPCSRd = "AddUserPoolClientSecretResponse";
const _AUUA = "AdminUpdateUserAttributes";
const _AUUAR = "AdminUpdateUserAttributesRequest";
const _AUUARd = "AdminUpdateUserAttributesResponse";
const _AVA = "AutoVerifiedAttributes";
const _AVT = "AttributeValueType";
const _AWSAI = "AWSAccountId";
const _Ar = "Arn";
const _As = "Assets";
const _At = "Attributes";
const _B = "Bytes";
const _BA = "BucketArn";
const _BE = "BlockEmail";
const _BIPRL = "BlockedIPRangeList";
const _C = "Category";
const _CA = "CustomAttributes";
const _CAC = "CreateAuthChallenge";
const _CALT = "CustomAttributesListType";
const _CAM = "CustomAuthMode";
const _CAR = "ClientAuthenticationResult";
const _CART = "ClientAuthenticationResultType";
const _CAa = "CallerArn";
const _CAe = "CertificateArn";
const _CAr = "CreatedAt";
const _CC = "ConfirmationCode";
const _CCAT = "CompromisedCredentialsActionsType";
const _CCD = "CompromisedCredentialsDetected";
const _CCO = "CredentialCreationOptions";
const _CCRC = "CompromisedCredentialsRiskConfiguration";
const _CCRCT = "CompromisedCredentialsRiskConfigurationType";
const _CD = "ContextData";
const _CDC = "CustomDomainConfig";
const _CDCT = "CustomDomainConfigType";
const _CDD = "CodeDeliveryDetails";
const _CDDL = "CodeDeliveryDetailsList";
const _CDDLT = "CodeDeliveryDetailsListType";
const _CDDT = "CodeDeliveryDetailsType";
const _CDFE = "CodeDeliveryFailureException";
const _CDR = "ConfirmDeviceRequest";
const _CDRo = "ConfirmDeviceResponse";
const _CDT = "ContextDataType";
const _CDo = "CompletionDate";
const _CDon = "ConfirmDevice";
const _CDr = "CreationDate";
const _CDu = "CustomDomain";
const _CELVCT = "CustomEmailLambdaVersionConfigType";
const _CES = "CustomEmailSender";
const _CFD = "CloudFrontDomain";
const _CFDl = "CloudFrontDistribution";
const _CFP = "ConfirmForgotPassword";
const _CFPR = "ConfirmForgotPasswordRequest";
const _CFPRo = "ConfirmForgotPasswordResponse";
const _CG = "CreateGroup";
const _CGR = "CreateGroupRequest";
const _CGRr = "CreateGroupResponse";
const _CI = "ClientId";
const _CIP = "CreateIdentityProvider";
const _CIPR = "CreateIdentityProviderRequest";
const _CIPRr = "CreateIdentityProviderResponse";
const _CIT = "ClientIdType";
const _CIr = "CredentialId";
const _CM = "ClientMetadata";
const _CME = "CodeMismatchException";
const _CMEo = "ConcurrentModificationException";
const _CMLB = "CreateManagedLoginBranding";
const _CMLBR = "CreateManagedLoginBrandingRequest";
const _CMLBRr = "CreateManagedLoginBrandingResponse";
const _CMo = "ColorMode";
const _CMom = "CompletionMessage";
const _CMu = "CustomMessage";
const _CN = "ChallengeName";
const _CNl = "ClientName";
const _CP = "ChallengeParameters";
const _CPR = "ChangePasswordRequest";
const _CPRh = "ChangePasswordResponse";
const _CPh = "ChangePassword";
const _CR = "ChallengeResponses";
const _CRLT = "ChallengeResponseListType";
const _CROND = "ChallengeRequiredOnNewDevice";
const _CRS = "CreateResourceServer";
const _CRSR = "CreateResourceServerRequest";
const _CRSRr = "CreateResourceServerResponse";
const _CRT = "ChallengeResponseType";
const _CRTh = "ChallengeResponsesType";
const _CRh = "ChallengeResponse";
const _CS = "ClientSecret";
const _CSCD = "ClientSecretCreateDate";
const _CSD = "ClientSecretDescriptor";
const _CSDLT = "ClientSecretDescriptorListType";
const _CSDT = "ClientSecretDescriptorType";
const _CSI = "ClientSecretId";
const _CSMSLVCT = "CustomSMSLambdaVersionConfigType";
const _CSMSS = "CustomSMSSender";
const _CSN = "ConfigurationSetName";
const _CSS = "CSS";
const _CSSV = "CSSVersion";
const _CST = "ClientSecretType";
const _CSU = "ConfirmSignUp";
const _CSUR = "ConfirmSignUpRequest";
const _CSURo = "ConfirmSignUpResponse";
const _CSV = "ClientSecretValue";
const _CSVH = "CSVHeader";
const _CSa = "CaseSensitive";
const _CSl = "ClientSecrets";
const _CSo = "ConfigurationSet";
const _CT = "CreateTerms";
const _CTR = "CreateTermsRequest";
const _CTRr = "CreateTermsResponse";
const _CUAF = "ConfiguredUserAuthFactors";
const _CUIJ = "CreateUserImportJob";
const _CUIJR = "CreateUserImportJobRequest";
const _CUIJRr = "CreateUserImportJobResponse";
const _CUP = "CreateUserPool";
const _CUPC = "CreateUserPoolClient";
const _CUPCR = "CreateUserPoolClientRequest";
const _CUPCRr = "CreateUserPoolClientResponse";
const _CUPD = "CreateUserPoolDomain";
const _CUPDR = "CreateUserPoolDomainRequest";
const _CUPDRr = "CreateUserPoolDomainResponse";
const _CUPR = "CreateUserPoolRequest";
const _CUPRR = "CreateUserPoolReplicaRequest";
const _CUPRRr = "CreateUserPoolReplicaResponse";
const _CUPRr = "CreateUserPoolResponse";
const _CUPRre = "CreateUserPoolReplica";
const _CURL = "CallbackURLs";
const _CWAR = "CompleteWebAuthnRegistration";
const _CWARR = "CompleteWebAuthnRegistrationRequest";
const _CWARRo = "CompleteWebAuthnRegistrationResponse";
const _CWLC = "CloudWatchLogsConfiguration";
const _CWLCT = "CloudWatchLogsConfigurationType";
const _CWLRA = "CloudWatchLogsRoleArn";
const _Ce = "Certificate";
const _Ci = "City";
const _Co = "Country";
const _Cod = "Code";
const _Cr = "Credential";
const _Cre = "Credentials";
const _D = "Device";
const _DA = "DeviceAttributes";
const _DAC = "DefineAuthChallenge";
const _DC = "DeviceConfiguration";
const _DCD = "DeviceCreateDate";
const _DCT = "DeviceConfigurationType";
const _DD = "DomainDescription";
const _DDM = "DesiredDeliveryMediums";
const _DDT = "DomainDescriptionType";
const _DEO = "DefaultEmailOption";
const _DG = "DeleteGroup";
const _DGK = "DeviceGroupKey";
const _DGR = "DeleteGroupRequest";
const _DIP = "DeleteIdentityProvider";
const _DIPR = "DeleteIdentityProviderRequest";
const _DIPRe = "DescribeIdentityProviderRequest";
const _DIPRes = "DescribeIdentityProviderResponse";
const _DIPe = "DescribeIdentityProvider";
const _DK = "DeviceKey";
const _DKEE = "DeviceKeyExistsException";
const _DLAD = "DeviceLastAuthenticatedDate";
const _DLMD = "DeviceLastModifiedDate";
const _DLT = "DeviceListType";
const _DM = "DeliveryMedium";
const _DMLB = "DeleteManagedLoginBranding";
const _DMLBBC = "DescribeManagedLoginBrandingByClient";
const _DMLBBCR = "DescribeManagedLoginBrandingByClientRequest";
const _DMLBBCRe = "DescribeManagedLoginBrandingByClientResponse";
const _DMLBR = "DeleteManagedLoginBrandingRequest";
const _DMLBRe = "DescribeManagedLoginBrandingRequest";
const _DMLBRes = "DescribeManagedLoginBrandingResponse";
const _DMLBe = "DescribeManagedLoginBranding";
const _DN = "DeviceName";
const _DOA = "DeveloperOnlyAttribute";
const _DOROUP = "DeviceOnlyRememberedOnUserPrompt";
const _DP = "DeletionProtection";
const _DPE = "DuplicateProviderException";
const _DRC = "DescribeRiskConfiguration";
const _DRCR = "DescribeRiskConfigurationRequest";
const _DRCRe = "DescribeRiskConfigurationResponse";
const _DRS = "DeviceRememberedStatus";
const _DRSR = "DeleteResourceServerRequest";
const _DRSRe = "DescribeResourceServerRequest";
const _DRSRes = "DescribeResourceServerResponse";
const _DRSe = "DeleteResourceServer";
const _DRSes = "DescribeResourceServer";
const _DRURI = "DefaultRedirectURI";
const _DSVC = "DeviceSecretVerifierConfig";
const _DSVCT = "DeviceSecretVerifierConfigType";
const _DT = "DeviceType";
const _DTBC = "DescribeTermsByClient";
const _DTBCR = "DescribeTermsByClientRequest";
const _DTBCRe = "DescribeTermsByClientResponse";
const _DTR = "DeleteTermsRequest";
const _DTRe = "DescribeTermsRequest";
const _DTRes = "DescribeTermsResponse";
const _DTe = "DeleteTerms";
const _DTes = "DescribeTerms";
const _DU = "DestinationUser";
const _DUA = "DeleteUserAttributes";
const _DUAR = "DeleteUserAttributesRequest";
const _DUARe = "DeleteUserAttributesResponse";
const _DUIJ = "DescribeUserImportJob";
const _DUIJR = "DescribeUserImportJobRequest";
const _DUIJRe = "DescribeUserImportJobResponse";
const _DUP = "DeleteUserPool";
const _DUPC = "DeleteUserPoolClient";
const _DUPCR = "DeleteUserPoolClientRequest";
const _DUPCRe = "DescribeUserPoolClientRequest";
const _DUPCRes = "DescribeUserPoolClientResponse";
const _DUPCS = "DeleteUserPoolClientSecret";
const _DUPCSR = "DeleteUserPoolClientSecretRequest";
const _DUPCSRe = "DeleteUserPoolClientSecretResponse";
const _DUPCe = "DescribeUserPoolClient";
const _DUPD = "DeleteUserPoolDomain";
const _DUPDR = "DeleteUserPoolDomainRequest";
const _DUPDRe = "DeleteUserPoolDomainResponse";
const _DUPDRes = "DescribeUserPoolDomainRequest";
const _DUPDResc = "DescribeUserPoolDomainResponse";
const _DUPDe = "DescribeUserPoolDomain";
const _DUPR = "DeleteUserPoolRequest";
const _DUPRR = "DeleteUserPoolReplicaRequest";
const _DUPRRe = "DeleteUserPoolReplicaResponse";
const _DUPRe = "DescribeUserPoolRequest";
const _DUPRel = "DeleteUserPoolReplica";
const _DUPRes = "DescribeUserPoolResponse";
const _DUPe = "DescribeUserPool";
const _DUR = "DeleteUserRequest";
const _DUe = "DeleteUser";
const _DWAC = "DeleteWebAuthnCredential";
const _DWACR = "DeleteWebAuthnCredentialRequest";
const _DWACRe = "DeleteWebAuthnCredentialResponse";
const _De = "Devices";
const _Des = "Destination";
const _Desc = "Description";
const _Do = "Domain";
const _E = "Enabled";
const _EA = "EventAction";
const _EAF = "ExplicitAuthFlows";
const _EC = "EmailConfiguration";
const _ECD = "EventContextData";
const _ECDT = "EventContextDataType";
const _ECE = "ExpiredCodeException";
const _ECF = "EmailConfigurationFailure";
const _ECT = "EmailConfigurationType";
const _ED = "EncodedData";
const _EF = "EventFeedback";
const _EFT = "EventFeedbackType";
const _EFv = "EventFilter";
const _EI = "EventId";
const _EIx = "ExternalId";
const _EIxp = "ExpiresIn";
const _EM = "EmailMessage";
const _EMBL = "EmailMessageByLink";
const _EMC = "EmailMfaConfiguration";
const _EMCT = "EmailMfaConfigType";
const _EMS = "EmailMfaSettings";
const _EMST = "EmailMfaSettingsType";
const _ENOU = "EstimatedNumberOfUsers";
const _EPAUCD = "EnablePropagateAdditionalUserContextData";
const _ER = "EventResponse";
const _ERT = "EventRiskType";
const _ERv = "EventRisk";
const _ES = "EventSource";
const _ESA = "EmailSendingAccount";
const _ESBL = "EmailSubjectByLink";
const _ESCT = "EumsSmsConfigurationType";
const _ESTMFAE = "EnableSoftwareTokenMFAException";
const _ESm = "EmailSubject";
const _ESu = "EumsSms";
const _ET = "EventType";
const _ETR = "EnableTokenRevocation";
const _EVM = "EmailVerificationMessage";
const _EVS = "EmailVerificationSubject";
const _En = "Enforcement";
const _Ex = "Extension";
const _F = "From";
const _FAC = "ForceAliasCreation";
const _FC = "FirehoseConfiguration";
const _FCN = "FriendlyCredentialName";
const _FCT = "FirehoseConfigurationType";
const _FCa = "FactorConfiguration";
const _FD = "FeedbackDate";
const _FDN = "FriendlyDeviceName";
const _FDR = "ForgetDeviceRequest";
const _FDo = "ForgetDevice";
const _FE = "ForbiddenException";
const _FLV = "FreeLimitValue";
const _FP = "ForgotPassword";
const _FPR = "ForgotPasswordRequest";
const _FPRo = "ForgotPasswordResponse";
const _FT = "FailoverType";
const _FTe = "FeedbackToken";
const _FU = "FailedUsers";
const _FUITE = "FeatureUnavailableInTierException";
const _FV = "FeedbackValue";
const _Fa = "Failover";
const _Fe = "Feature";
const _Fi = "Filter";
const _G = "Groups";
const _GCSVH = "GetCSVHeader";
const _GCSVHR = "GetCSVHeaderRequest";
const _GCSVHRe = "GetCSVHeaderResponse";
const _GCT = "GetClientToken";
const _GCTR = "GetClientTokenRequest";
const _GCTRe = "GetClientTokenResponse";
const _GD = "GetDevice";
const _GDR = "GetDeviceRequest";
const _GDRe = "GetDeviceResponse";
const _GEE = "GroupExistsException";
const _GG = "GetGroup";
const _GGR = "GetGroupRequest";
const _GGRe = "GetGroupResponse";
const _GIPBI = "GetIdentityProviderByIdentifier";
const _GIPBIR = "GetIdentityProviderByIdentifierRequest";
const _GIPBIRe = "GetIdentityProviderByIdentifierResponse";
const _GLDC = "GetLogDeliveryConfiguration";
const _GLDCR = "GetLogDeliveryConfigurationRequest";
const _GLDCRe = "GetLogDeliveryConfigurationResponse";
const _GLT = "GroupListType";
const _GN = "GroupName";
const _GPL = "GetProvisionedLimit";
const _GPLR = "GetProvisionedLimitRequest";
const _GPLRe = "GetProvisionedLimitResponse";
const _GS = "GenerateSecret";
const _GSC = "GetSigningCertificate";
const _GSCR = "GetSigningCertificateRequest";
const _GSCRe = "GetSigningCertificateResponse";
const _GSO = "GlobalSignOut";
const _GSOR = "GlobalSignOutRequest";
const _GSORl = "GlobalSignOutResponse";
const _GT = "GroupType";
const _GTFRT = "GetTokensFromRefreshToken";
const _GTFRTR = "GetTokensFromRefreshTokenRequest";
const _GTFRTRe = "GetTokensFromRefreshTokenResponse";
const _GU = "GetUser";
const _GUAF = "GetUserAuthFactors";
const _GUAFR = "GetUserAuthFactorsRequest";
const _GUAFRe = "GetUserAuthFactorsResponse";
const _GUAVC = "GetUserAttributeVerificationCode";
const _GUAVCR = "GetUserAttributeVerificationCodeRequest";
const _GUAVCRe = "GetUserAttributeVerificationCodeResponse";
const _GUIC = "GetUICustomization";
const _GUICR = "GetUICustomizationRequest";
const _GUICRe = "GetUICustomizationResponse";
const _GUPMC = "GetUserPoolMfaConfig";
const _GUPMCR = "GetUserPoolMfaConfigRequest";
const _GUPMCRe = "GetUserPoolMfaConfigResponse";
const _GUR = "GetUserRequest";
const _GURe = "GetUserResponse";
const _Gr = "Group";
const _HA = "HighAction";
const _HB = "HtmlBody";
const _HH = "HttpHeaders";
const _HHL = "HttpHeaderList";
const _HHt = "HttpHeader";
const _I = "Identifier";
const _IA = "IpAddress";
const _IAR = "InitiateAuthRequest";
const _IARn = "InitiateAuthResponse";
const _IAn = "InitiateAuth";
const _IC = "IssuerConfiguration";
const _ICT = "IssuerConfigurationType";
const _IEE = "InternalErrorException";
const _IEI = "InEntityId";
const _IERAPE = "InvalidEmailRoleAccessPolicyException";
const _IF = "InboundFederation";
const _IFLT = "InboundFederationLambdaType";
const _IFm = "ImageFile";
const _II = "IdpIdentifiers";
const _IId = "IdpIdentifier";
const _ILRE = "InvalidLambdaResponseException";
const _IMT = "InviteMessageTemplate";
const _IOAFE = "InvalidOAuthFlowException";
const _IP = "IdentityProvider";
const _IPE = "InvalidParameterException";
const _IPEn = "InvalidPasswordException";
const _IPT = "IdentityProviderType";
const _ISE = "InternalServerException";
const _ISRAPE = "InvalidSmsRoleAccessPolicyException";
const _ISRTRE = "InvalidSmsRoleTrustRelationshipException";
const _IT = "IdToken";
const _ITI = "InTemplateId";
const _ITV = "IdTokenValidity";
const _IU = "ImageUrl";
const _IUPCE = "InvalidUserPoolConfigurationException";
const _IUm = "ImportedUsers";
const _Id = "Id";
const _JI = "JobId";
const _JN = "JobName";
const _KC = "KeyConfiguration";
const _KCT = "KeyConfigurationType";
const _KKA = "KmsKeyArn";
const _KMSKID = "KMSKeyID";
const _KT = "KeyType";
const _L = "Limit";
const _LA = "LowAction";
const _LAa = "LambdaArn";
const _LC = "LambdaConfig";
const _LCLT = "LogConfigurationListType";
const _LCT = "LambdaConfigType";
const _LCTo = "LogConfigurationType";
const _LCi = "LimitClass";
const _LCo = "LogConfigurations";
const _LD = "LimitDefinition";
const _LDC = "LogDeliveryConfiguration";
const _LDCT = "LogDeliveryConfigurationType";
const _LDR = "ListDevicesRequest";
const _LDRi = "ListDevicesResponse";
const _LDT = "LimitDefinitionType";
const _LDi = "ListDevices";
const _LEE = "LimitExceededException";
const _LG = "ListGroups";
const _LGA = "LogGroupArn";
const _LGR = "ListGroupsRequest";
const _LGRi = "ListGroupsResponse";
const _LIP = "ListIdentityProviders";
const _LIPR = "ListIdentityProvidersRequest";
const _LIPRi = "ListIdentityProvidersResponse";
const _LL = "LogLevel";
const _LMD = "LastModifiedDate";
const _LRS = "ListResourceServers";
const _LRSR = "ListResourceServersRequest";
const _LRSRi = "ListResourceServersResponse";
const _LT = "LimitType";
const _LTFR = "ListTagsForResource";
const _LTFRR = "ListTagsForResourceRequest";
const _LTFRRi = "ListTagsForResourceResponse";
const _LTR = "ListTermsRequest";
const _LTRi = "ListTermsResponse";
const _LTi = "ListTerms";
const _LU = "ListUsers";
const _LUIG = "ListUsersInGroup";
const _LUIGR = "ListUsersInGroupRequest";
const _LUIGRi = "ListUsersInGroupResponse";
const _LUIJ = "ListUserImportJobs";
const _LUIJR = "ListUserImportJobsRequest";
const _LUIJRi = "ListUserImportJobsResponse";
const _LUP = "ListUserPools";
const _LUPC = "ListUserPoolClients";
const _LUPCR = "ListUserPoolClientsRequest";
const _LUPCRi = "ListUserPoolClientsResponse";
const _LUPCS = "ListUserPoolClientSecrets";
const _LUPCSR = "ListUserPoolClientSecretsRequest";
const _LUPCSRi = "ListUserPoolClientSecretsResponse";
const _LUPR = "ListUserPoolsRequest";
const _LUPRR = "ListUserPoolReplicasRequest";
const _LUPRRi = "ListUserPoolReplicasResponse";
const _LUPRi = "ListUserPoolsResponse";
const _LUPRis = "ListUserPoolReplicas";
const _LUR = "ListUsersRequest";
const _LURL = "LogoutURLs";
const _LURi = "ListUsersResponse";
const _LV = "LambdaVersion";
const _LWAC = "ListWebAuthnCredentials";
const _LWACR = "ListWebAuthnCredentialsRequest";
const _LWACRi = "ListWebAuthnCredentialsResponse";
const _Li = "Links";
const _M = "Message";
const _MA = "MediumAction";
const _MAe = "MessageAction";
const _MC = "MfaConfiguration";
const _ME = "MfaEmail";
const _MFAMNFE = "MFAMethodNotFoundException";
const _MFAO = "MFAOptions";
const _MFAOLT = "MFAOptionListType";
const _MFAOT = "MFAOptionType";
const _ML = "MinimumLength";
const _MLB = "ManagedLoginBranding";
const _MLBEE = "ManagedLoginBrandingExistsException";
const _MLBI = "ManagedLoginBrandingId";
const _MLBT = "ManagedLoginBrandingType";
const _MLV = "ManagedLoginVersion";
const _MLa = "MaxLength";
const _MLi = "MinLength";
const _MR = "MaxResults";
const _MTT = "MessageTemplateType";
const _MV = "MinValue";
const _MVa = "MaxValue";
const _Mu = "Mutable";
const _N = "Notify";
const _NAC = "NumberAttributeConstraints";
const _NACT = "NumberAttributeConstraintsType";
const _NAE = "NotAuthorizedException";
const _NAEo = "NoActionEmail";
const _NC = "NotifyConfiguration";
const _NCT = "NotifyConfigurationType";
const _NDM = "NewDeviceMetadata";
const _NDMT = "NewDeviceMetadataType";
const _NET = "NotifyEmailType";
const _NT = "NextToken";
const _Na = "Name";
const _OI = "OriginationIdentity";
const _ONEE = "OperationNotEnabledException";
const _P = "Password";
const _PA = "PreAuthentication";
const _PAN = "ProviderAttributeName";
const _PAV = "ProviderAttributeValue";
const _PAo = "PostAuthentication";
const _PC = "PostConfirmation";
const _PD = "ProviderDetails";
const _PDr = "ProviderDescription";
const _PHA = "PasswordHashingAlgorithm";
const _PHPVE = "PasswordHistoryPolicyViolationException";
const _PHS = "PasswordHistorySize";
const _PLT = "ProvidersListType";
const _PLV = "ProvisionedLimitValue";
const _PM = "PreferredMfa";
const _PMS = "PreferredMfaSetting";
const _PN = "ProviderName";
const _PNME = "PreconditionNotMetException";
const _PNo = "PoolName";
const _PP = "ProposedPassword";
const _PPT = "PasswordPolicyType";
const _PPa = "PasswordPolicy";
const _PPr = "PreviousPassword";
const _PRHCI = "PrimaryRoute53HealthCheckId";
const _PRRE = "PasswordResetRequiredException";
const _PSU = "PreSignUp";
const _PSUr = "PreSignedUrl";
const _PT = "PasswordType";
const _PTG = "PreTokenGeneration";
const _PTGC = "PreTokenGenerationConfig";
const _PTGVCT = "PreTokenGenerationVersionConfigType";
const _PTa = "PaginationToken";
const _PTr = "ProviderType";
const _PUEE = "PreventUserExistenceErrors";
const _PUIT = "ProviderUserIdentifierType";
const _PV = "PasswordVerifier";
const _Pe = "Permanent";
const _Po = "Policies";
const _Pr = "Precedence";
const _Pri = "Priority";
const _Pro = "Provider";
const _Prov = "Providers";
const _R = "Routing";
const _RA = "RoleArn";
const _RAe = "ReadAttributes";
const _RAes = "ResourceArn";
const _RC = "RiskConfiguration";
const _RCC = "ResendConfirmationCode";
const _RCCR = "ResendConfirmationCodeRequest";
const _RCCRe = "ResendConfirmationCodeResponse";
const _RCT = "RiskConfigurationType";
const _RD = "RiskDecision";
const _REC = "RiskExceptionConfiguration";
const _RECT = "RiskExceptionConfigurationType";
const _RGPS = "RetryGracePeriodSeconds";
const _RI = "ResourceId";
const _RL = "RiskLevel";
const _RLV = "RequestedLimitValue";
const _RLe = "RequireLowercase";
const _RM = "RecoveryMechanisms";
const _RMR = "ReturnMergedResources";
const _RMT = "RecoveryMechanismsType";
const _RN = "RegionName";
const _RNFE = "ResourceNotFoundException";
const _RNe = "RequireNumbers";
const _ROT = "RecoveryOptionType";
const _RPI = "RelyingPartyId";
const _RR = "ReplicaRegions";
const _RS = "ResourceServer";
const _RSLT = "ResourceServersListType";
const _RSSLT = "ResourceServerScopeListType";
const _RSST = "ResourceServerScopeType";
const _RST = "ResourceServerType";
const _RSe = "ResourceServers";
const _RSeq = "RequireSymbols";
const _RT = "RefreshToken";
const _RTAC = "RespondToAuthChallenge";
const _RTACR = "RespondToAuthChallengeRequest";
const _RTACRe = "RespondToAuthChallengeResponse";
const _RTEA = "ReplyToEmailAddress";
const _RTR = "RefreshTokenRotation";
const _RTRE = "RefreshTokenReuseException";
const _RTRT = "RefreshTokenRotationType";
const _RTRe = "RevokeTokenRequest";
const _RTRev = "RevokeTokenResponse";
const _RTV = "RefreshTokenValidity";
const _RTe = "ReplyTo";
const _RTev = "RevokeToken";
const _RTo = "RoutingType";
const _RU = "RequireUppercase";
const _Re = "Region";
const _Req = "Required";
const _Ro = "Role";
const _S = "Session";
const _SA = "SourceArn";
const _SAC = "StringAttributeConstraints";
const _SACT = "StringAttributeConstraintsType";
const _SALT = "SchemaAttributesListType";
const _SAM = "SmsAuthenticationMessage";
const _SAT = "SchemaAttributeType";
const _SAc = "SchemaAttributes";
const _SAt = "StreamArn";
const _SB = "S3Bucket";
const _SC = "SecretCode";
const _SCA = "SnsCallerArn";
const _SCF = "SmsConfigurationFailure";
const _SCT = "SecretCodeType";
const _SCTm = "SmsConfigurationType";
const _SCTo = "S3ConfigurationType";
const _SCm = "SmsConfiguration";
const _SCo = "S3Configuration";
const _SD = "ScopeDescription";
const _SDNEE = "ScopeDoesNotExistException";
const _SDt = "StartDate";
const _SH = "SecretHash";
const _SHT = "SecretHashType";
const _SIP = "SupportedIdentityProviders";
const _SIPRL = "SkippedIPRangeList";
const _SIPT = "SignInPolicyType";
const _SIPi = "SignInPolicy";
const _SLDC = "SetLogDeliveryConfiguration";
const _SLDCR = "SetLogDeliveryConfigurationRequest";
const _SLDCRe = "SetLogDeliveryConfigurationResponse";
const _SM = "SmsMessage";
const _SMC = "SmsMfaConfiguration";
const _SMCT = "SmsMfaConfigType";
const _SMSM = "SMSMessage";
const _SMSMS = "SMSMfaSettings";
const _SMSMST = "SMSMfaSettingsType";
const _SN = "ServerName";
const _SNc = "ScopeName";
const _SP = "ServerPath";
const _SPe = "SecurityPolicy";
const _SQEE = "ServiceQuotaExceededException";
const _SR = "SecondaryRegion";
const _SRC = "SetRiskConfiguration";
const _SRCR = "SetRiskConfigurationRequest";
const _SRCRe = "SetRiskConfigurationResponse";
const _SRn = "SnsRegion";
const _ST = "SessionType";
const _STMC = "SoftwareTokenMfaConfiguration";
const _STMCT = "SoftwareTokenMfaConfigType";
const _STMFANFE = "SoftwareTokenMFANotFoundException";
const _STMFAUCT = "SoftwareTokenMFAUserCodeType";
const _STMS = "SoftwareTokenMfaSettings";
const _STMST = "SoftwareTokenMfaSettingsType";
const _SU = "SourceUser";
const _SUIC = "SetUICustomization";
const _SUICR = "SetUICustomizationRequest";
const _SUICRe = "SetUICustomizationResponse";
const _SUIJ = "StartUserImportJob";
const _SUIJR = "StartUserImportJobRequest";
const _SUIJRt = "StartUserImportJobResponse";
const _SUIJRto = "StopUserImportJobRequest";
const _SUIJRtop = "StopUserImportJobResponse";
const _SUIJt = "StopUserImportJob";
const _SUMFAP = "SetUserMFAPreference";
const _SUMFAPR = "SetUserMFAPreferenceRequest";
const _SUMFAPRe = "SetUserMFAPreferenceResponse";
const _SUPMC = "SetUserPoolMfaConfig";
const _SUPMCR = "SetUserPoolMfaConfigRequest";
const _SUPMCRe = "SetUserPoolMfaConfigResponse";
const _SUR = "SignUpRequest";
const _SURi = "SignUpResponse";
const _SUS = "SetUserSettings";
const _SUSR = "SetUserSettingsRequest";
const _SUSRe = "SetUserSettingsResponse";
const _SUi = "SignUp";
const _SUk = "SkippedUsers";
const _SVM = "SmsVerificationMessage";
const _SWAR = "StartWebAuthnRegistration";
const _SWARR = "StartWebAuthnRegistrationRequest";
const _SWARRt = "StartWebAuthnRegistrationResponse";
const _Sa = "Salt";
const _Sc = "Scopes";
const _Sch = "Schema";
const _Se = "Settings";
const _Sec = "Secret";
const _St = "Status";
const _Su = "Subject";
const _T = "Terms";
const _TB = "TextBody";
const _TCNAE = "TierChangeNotAllowedException";
const _TDLT = "TermsDescriptionListType";
const _TDT = "TermsDescriptionType";
const _TEE = "TermsExistsException";
const _TI = "TermsId";
const _TK = "TagKeys";
const _TMFAE = "TooManyFailedAttemptsException";
const _TMRE = "TooManyRequestsException";
const _TMT = "TokenModelType";
const _TN = "TermsName";
const _TP = "TemporaryPassword";
const _TPVD = "TemporaryPasswordValidityDays";
const _TR = "TagResource";
const _TRR = "TagResourceRequest";
const _TRRa = "TagResourceResponse";
const _TS = "TermsSource";
const _TT = "TokenType";
const _TTe = "TermsType";
const _TVU = "TokenValidityUnits";
const _TVUT = "TokenValidityUnitsType";
const _Ta = "Tags";
const _Ti = "Timezone";
const _To = "Token";
const _Ty = "Type";
const _U = "Username";
const _UA = "UserAttributes";
const _UAEF = "UpdateAuthEventFeedback";
const _UAEFR = "UpdateAuthEventFeedbackRequest";
const _UAEFRp = "UpdateAuthEventFeedbackResponse";
const _UAN = "UserAttributeNames";
const _UAUS = "UserAttributeUpdateSettings";
const _UAUST = "UserAttributeUpdateSettingsType";
const _UAVD = "UnusedAccountValidityDays";
const _UAs = "UsernameAttributes";
const _UC = "UsernameConfiguration";
const _UCD = "UserCreateDate";
const _UCDT = "UserContextDataType";
const _UCDs = "UserContextData";
const _UCN = "UserConfirmationNecessary";
const _UCPV = "UseCognitoProvidedValues";
const _UCT = "UsernameConfigurationType";
const _UCs = "UserConfirmed";
const _UCse = "UserCode";
const _UDS = "UserDataShared";
const _UDSR = "UpdateDeviceStatusRequest";
const _UDSRp = "UpdateDeviceStatusResponse";
const _UDSp = "UpdateDeviceStatus";
const _UE = "UnauthorizedException";
const _UEE = "UsernameExistsException";
const _UG = "UpdateGroup";
const _UGR = "UpdateGroupRequest";
const _UGRp = "UpdateGroupResponse";
const _UIC = "UICustomization";
const _UICT = "UICustomizationType";
const _UIIPE = "UserImportInProgressException";
const _UIJ = "UserImportJob";
const _UIJLT = "UserImportJobsListType";
const _UIJT = "UserImportJobType";
const _UIJs = "UserImportJobs";
const _UIP = "UpdateIdentityProvider";
const _UIPE = "UnsupportedIdentityProviderException";
const _UIPR = "UpdateIdentityProviderRequest";
const _UIPRp = "UpdateIdentityProviderResponse";
const _ULE = "UnexpectedLambdaException";
const _ULMD = "UserLastModifiedDate";
const _ULT = "UsersListType";
const _ULVE = "UserLambdaValidationException";
const _UM = "UserMigration";
const _UMFASL = "UserMFASettingList";
const _UMLB = "UpdateManagedLoginBranding";
const _UMLBR = "UpdateManagedLoginBrandingRequest";
const _UMLBRp = "UpdateManagedLoginBrandingResponse";
const _UNCE = "UserNotConfirmedException";
const _UNFE = "UserNotFoundException";
const _UOE = "UnsupportedOperationException";
const _UP = "UserPool";
const _UPA = "UserPoolArn";
const _UPAO = "UserPoolAddOns";
const _UPAONEE = "UserPoolAddOnNotEnabledException";
const _UPAOT = "UserPoolAddOnsType";
const _UPC = "UserPoolClient";
const _UPCD = "UserPoolClientDescription";
const _UPCLT = "UserPoolClientListType";
const _UPCT = "UserPoolClientType";
const _UPCs = "UserPoolClients";
const _UPDT = "UserPoolDescriptionType";
const _UPI = "UserPoolId";
const _UPL = "UpdateProvisionedLimit";
const _UPLR = "UpdateProvisionedLimitRequest";
const _UPLRp = "UpdateProvisionedLimitResponse";
const _UPLT = "UserPoolListType";
const _UPPT = "UserPoolPolicyType";
const _UPR = "UserPoolReplica";
const _UPRLT = "UserPoolReplicaListType";
const _UPRT = "UserPoolReplicaType";
const _UPRs = "UserPoolReplicas";
const _UPT = "UserPoolTags";
const _UPTE = "UserPoolTaggingException";
const _UPTs = "UserPoolTier";
const _UPTse = "UserPoolType";
const _UPs = "UserPools";
const _UR = "UntagResource";
const _URR = "UntagResourceRequest";
const _URRn = "UntagResourceResponse";
const _URS = "UpdateResourceServer";
const _URSR = "UpdateResourceServerRequest";
const _URSRp = "UpdateResourceServerResponse";
const _US = "UserStatus";
const _USs = "UserSub";
const _UT = "UsernameType";
const _UTR = "UpdateTermsRequest";
const _UTRp = "UpdateTermsResponse";
const _UTTE = "UnsupportedTokenTypeException";
const _UTp = "UpdateTerms";
const _UTs = "UserType";
const _UUA = "UpdateUserAttributes";
const _UUAR = "UpdateUserAttributesRequest";
const _UUARp = "UpdateUserAttributesResponse";
const _UUP = "UpdateUserPool";
const _UUPC = "UpdateUserPoolClient";
const _UUPCR = "UpdateUserPoolClientRequest";
const _UUPCRp = "UpdateUserPoolClientResponse";
const _UUPD = "UpdateUserPoolDomain";
const _UUPDR = "UpdateUserPoolDomainRequest";
const _UUPDRp = "UpdateUserPoolDomainResponse";
const _UUPR = "UpdateUserPoolRequest";
const _UUPRR = "UpdateUserPoolReplicaRequest";
const _UUPRRp = "UpdateUserPoolReplicaResponse";
const _UUPRp = "UpdateUserPoolResponse";
const _UUPRpd = "UpdateUserPoolReplica";
const _UUSE = "UnsupportedUserStateException";
const _UV = "UserVerification";
const _Us = "User";
const _Use = "Users";
const _V = "Value";
const _VACR = "VerifyAuthChallengeResponse";
const _VD = "ValidationData";
const _VMT = "VerificationMessageTemplate";
const _VMTT = "VerificationMessageTemplateType";
const _VST = "VerifySoftwareToken";
const _VSTR = "VerifySoftwareTokenRequest";
const _VSTRe = "VerifySoftwareTokenResponse";
const _VUA = "VerifyUserAttribute";
const _VUAR = "VerifyUserAttributeRequest";
const _VUARe = "VerifyUserAttributeResponse";
const _Ve = "Version";
const _WA = "WriteAttributes";
const _WAC = "WebAuthnConfiguration";
const _WACD = "WebAuthnCredentialDescription";
const _WACDLT = "WebAuthnCredentialDescriptionListType";
const _WACME = "WebAuthnClientMismatchException";
const _WACMEe = "WebAuthnConfigurationMissingException";
const _WACNFE = "WebAuthnChallengeNotFoundException";
const _WACNSE = "WebAuthnCredentialNotSupportedException";
const _WACT = "WebAuthnConfigurationType";
const _WAMS = "WebAuthnMfaSettings";
const _WAMST = "WebAuthnMfaSettingsType";
const _WANEE = "WebAuthnNotEnabledException";
const _WAONAE = "WebAuthnOriginNotAllowedException";
const _WARPME = "WebAuthnRelyingPartyMismatchException";
const _c = "client";
const _e = "error";
const _hE = "httpError";
const _hN = "headerName";
const _hV = "headerValue";
const _m = "message";
const _rC = "reasonCode";
const _s = "smithy.ts.sdk.synthetic.com.amazonaws.cognitoidentityprovider";
const _se = "server";
const n0 = "com.amazonaws.cognitoidentityprovider";
const _s_registry = new TypeRegistry(_s);
var CognitoIdentityProviderServiceException$ = [-3, _s, "CognitoIdentityProviderServiceException", 0, [], []];
_s_registry.registerError(CognitoIdentityProviderServiceException$, CognitoIdentityProviderServiceException);
const n0_registry = new TypeRegistry(n0);
var AccessDeniedException$ = [-3, n0, _ADE,
    { [_e]: _c, [_hE]: 403 },
    [_m],
    [0]
];
n0_registry.registerError(AccessDeniedException$, AccessDeniedException);
var AliasExistsException$ = [-3, n0, _AEE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(AliasExistsException$, AliasExistsException);
var CodeDeliveryFailureException$ = [-3, n0, _CDFE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(CodeDeliveryFailureException$, CodeDeliveryFailureException);
var CodeMismatchException$ = [-3, n0, _CME,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(CodeMismatchException$, CodeMismatchException);
var ConcurrentModificationException$ = [-3, n0, _CMEo,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(ConcurrentModificationException$, ConcurrentModificationException);
var DeviceKeyExistsException$ = [-3, n0, _DKEE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(DeviceKeyExistsException$, DeviceKeyExistsException);
var DuplicateProviderException$ = [-3, n0, _DPE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(DuplicateProviderException$, DuplicateProviderException);
var EnableSoftwareTokenMFAException$ = [-3, n0, _ESTMFAE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(EnableSoftwareTokenMFAException$, EnableSoftwareTokenMFAException);
var ExpiredCodeException$ = [-3, n0, _ECE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(ExpiredCodeException$, ExpiredCodeException);
var FeatureUnavailableInTierException$ = [-3, n0, _FUITE,
    { [_e]: _c, [_hE]: 403 },
    [_m],
    [0]
];
n0_registry.registerError(FeatureUnavailableInTierException$, FeatureUnavailableInTierException);
var ForbiddenException$ = [-3, n0, _FE,
    { [_e]: _c, [_hE]: 403 },
    [_m],
    [0]
];
n0_registry.registerError(ForbiddenException$, ForbiddenException);
var GroupExistsException$ = [-3, n0, _GEE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(GroupExistsException$, GroupExistsException);
var InternalErrorException$ = [-3, n0, _IEE,
    { [_e]: _se },
    [_m],
    [0]
];
n0_registry.registerError(InternalErrorException$, InternalErrorException);
var InternalServerException$ = [-3, n0, _ISE,
    { [_e]: _se },
    [_m],
    [0]
];
n0_registry.registerError(InternalServerException$, InternalServerException);
var InvalidEmailRoleAccessPolicyException$ = [-3, n0, _IERAPE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(InvalidEmailRoleAccessPolicyException$, InvalidEmailRoleAccessPolicyException);
var InvalidLambdaResponseException$ = [-3, n0, _ILRE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(InvalidLambdaResponseException$, InvalidLambdaResponseException);
var InvalidOAuthFlowException$ = [-3, n0, _IOAFE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(InvalidOAuthFlowException$, InvalidOAuthFlowException);
var InvalidParameterException$ = [-3, n0, _IPE,
    { [_e]: _c, [_hE]: 400 },
    [_m, _rC],
    [0, 0]
];
n0_registry.registerError(InvalidParameterException$, InvalidParameterException);
var InvalidPasswordException$ = [-3, n0, _IPEn,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(InvalidPasswordException$, InvalidPasswordException);
var InvalidSmsRoleAccessPolicyException$ = [-3, n0, _ISRAPE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(InvalidSmsRoleAccessPolicyException$, InvalidSmsRoleAccessPolicyException);
var InvalidSmsRoleTrustRelationshipException$ = [-3, n0, _ISRTRE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(InvalidSmsRoleTrustRelationshipException$, InvalidSmsRoleTrustRelationshipException);
var InvalidUserPoolConfigurationException$ = [-3, n0, _IUPCE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(InvalidUserPoolConfigurationException$, InvalidUserPoolConfigurationException);
var LimitExceededException$ = [-3, n0, _LEE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(LimitExceededException$, LimitExceededException);
var ManagedLoginBrandingExistsException$ = [-3, n0, _MLBEE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(ManagedLoginBrandingExistsException$, ManagedLoginBrandingExistsException);
var MFAMethodNotFoundException$ = [-3, n0, _MFAMNFE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(MFAMethodNotFoundException$, MFAMethodNotFoundException);
var NotAuthorizedException$ = [-3, n0, _NAE,
    { [_e]: _c, [_hE]: 403 },
    [_m],
    [0]
];
n0_registry.registerError(NotAuthorizedException$, NotAuthorizedException);
var OperationNotEnabledException$ = [-3, n0, _ONEE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(OperationNotEnabledException$, OperationNotEnabledException);
var PasswordHistoryPolicyViolationException$ = [-3, n0, _PHPVE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(PasswordHistoryPolicyViolationException$, PasswordHistoryPolicyViolationException);
var PasswordResetRequiredException$ = [-3, n0, _PRRE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(PasswordResetRequiredException$, PasswordResetRequiredException);
var PreconditionNotMetException$ = [-3, n0, _PNME,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(PreconditionNotMetException$, PreconditionNotMetException);
var RefreshTokenReuseException$ = [-3, n0, _RTRE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(RefreshTokenReuseException$, RefreshTokenReuseException);
var ResourceNotFoundException$ = [-3, n0, _RNFE,
    { [_e]: _c, [_hE]: 404 },
    [_m],
    [0]
];
n0_registry.registerError(ResourceNotFoundException$, ResourceNotFoundException);
var ScopeDoesNotExistException$ = [-3, n0, _SDNEE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(ScopeDoesNotExistException$, ScopeDoesNotExistException);
var ServiceQuotaExceededException$ = [-3, n0, _SQEE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(ServiceQuotaExceededException$, ServiceQuotaExceededException);
var SoftwareTokenMFANotFoundException$ = [-3, n0, _STMFANFE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(SoftwareTokenMFANotFoundException$, SoftwareTokenMFANotFoundException);
var TermsExistsException$ = [-3, n0, _TEE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(TermsExistsException$, TermsExistsException);
var TierChangeNotAllowedException$ = [-3, n0, _TCNAE,
    { [_e]: _c, [_hE]: 403 },
    [_m],
    [0]
];
n0_registry.registerError(TierChangeNotAllowedException$, TierChangeNotAllowedException);
var TooManyFailedAttemptsException$ = [-3, n0, _TMFAE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(TooManyFailedAttemptsException$, TooManyFailedAttemptsException);
var TooManyRequestsException$ = [-3, n0, _TMRE,
    { [_e]: _c, [_hE]: 429 },
    [_m],
    [0]
];
n0_registry.registerError(TooManyRequestsException$, TooManyRequestsException);
var UnauthorizedException$ = [-3, n0, _UE,
    { [_e]: _c, [_hE]: 401 },
    [_m],
    [0]
];
n0_registry.registerError(UnauthorizedException$, UnauthorizedException);
var UnexpectedLambdaException$ = [-3, n0, _ULE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(UnexpectedLambdaException$, UnexpectedLambdaException);
var UnsupportedIdentityProviderException$ = [-3, n0, _UIPE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(UnsupportedIdentityProviderException$, UnsupportedIdentityProviderException);
var UnsupportedOperationException$ = [-3, n0, _UOE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(UnsupportedOperationException$, UnsupportedOperationException);
var UnsupportedTokenTypeException$ = [-3, n0, _UTTE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(UnsupportedTokenTypeException$, UnsupportedTokenTypeException);
var UnsupportedUserStateException$ = [-3, n0, _UUSE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(UnsupportedUserStateException$, UnsupportedUserStateException);
var UserImportInProgressException$ = [-3, n0, _UIIPE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(UserImportInProgressException$, UserImportInProgressException);
var UserLambdaValidationException$ = [-3, n0, _ULVE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(UserLambdaValidationException$, UserLambdaValidationException);
var UsernameExistsException$ = [-3, n0, _UEE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(UsernameExistsException$, UsernameExistsException);
var UserNotConfirmedException$ = [-3, n0, _UNCE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(UserNotConfirmedException$, UserNotConfirmedException);
var UserNotFoundException$ = [-3, n0, _UNFE,
    { [_e]: _c, [_hE]: 404 },
    [_m],
    [0]
];
n0_registry.registerError(UserNotFoundException$, UserNotFoundException);
var UserPoolAddOnNotEnabledException$ = [-3, n0, _UPAONEE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(UserPoolAddOnNotEnabledException$, UserPoolAddOnNotEnabledException);
var UserPoolTaggingException$ = [-3, n0, _UPTE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(UserPoolTaggingException$, UserPoolTaggingException);
var WebAuthnChallengeNotFoundException$ = [-3, n0, _WACNFE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(WebAuthnChallengeNotFoundException$, WebAuthnChallengeNotFoundException);
var WebAuthnClientMismatchException$ = [-3, n0, _WACME,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(WebAuthnClientMismatchException$, WebAuthnClientMismatchException);
var WebAuthnConfigurationMissingException$ = [-3, n0, _WACMEe,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(WebAuthnConfigurationMissingException$, WebAuthnConfigurationMissingException);
var WebAuthnCredentialNotSupportedException$ = [-3, n0, _WACNSE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(WebAuthnCredentialNotSupportedException$, WebAuthnCredentialNotSupportedException);
var WebAuthnNotEnabledException$ = [-3, n0, _WANEE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(WebAuthnNotEnabledException$, WebAuthnNotEnabledException);
var WebAuthnOriginNotAllowedException$ = [-3, n0, _WAONAE,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(WebAuthnOriginNotAllowedException$, WebAuthnOriginNotAllowedException);
var WebAuthnRelyingPartyMismatchException$ = [-3, n0, _WARPME,
    { [_e]: _c, [_hE]: 400 },
    [_m],
    [0]
];
n0_registry.registerError(WebAuthnRelyingPartyMismatchException$, WebAuthnRelyingPartyMismatchException);
const errorTypeRegistries = [
    _s_registry,
    n0_registry,
];
var AttributeValueType = [0, n0, _AVT, 8, 0];
var ClientIdType = [0, n0, _CIT, 8, 0];
var ClientSecretType = [0, n0, _CST, 8, 0];
var PasswordType = [0, n0, _PT, 8, 0];
var SecretCodeType = [0, n0, _SCT, 8, 0];
var SecretHashType = [0, n0, _SHT, 8, 0];
var SessionType = [0, n0, _ST, 8, 0];
var SoftwareTokenMFAUserCodeType = [0, n0, _STMFAUCT, 8, 0];
var TokenModelType = [0, n0, _TMT, 8, 0];
var UsernameType = [0, n0, _UT, 8, 0];
var AccountRecoverySettingType$ = [3, n0, _ARST,
    0,
    [_RM],
    [() => RecoveryMechanismsType]
];
var AccountTakeoverActionsType$ = [3, n0, _ATAT,
    0,
    [_LA, _MA, _HA],
    [() => AccountTakeoverActionType$, () => AccountTakeoverActionType$, () => AccountTakeoverActionType$]
];
var AccountTakeoverActionType$ = [3, n0, _ATATc,
    0,
    [_N, _EA],
    [2, 0], 2
];
var AccountTakeoverRiskConfigurationType$ = [3, n0, _ATRCT,
    0,
    [_A, _NC],
    [() => AccountTakeoverActionsType$, () => NotifyConfigurationType$], 1
];
var AddCustomAttributesRequest$ = [3, n0, _ACAR,
    0,
    [_UPI, _CA],
    [0, () => CustomAttributesListType], 2
];
var AddCustomAttributesResponse$ = [3, n0, _ACARd,
    0,
    [],
    []
];
var AddUserPoolClientSecretRequest$ = [3, n0, _AUPCSR,
    0,
    [_UPI, _CI, _CS],
    [0, [() => ClientIdType, 0], [() => ClientSecretType, 0]], 2
];
var AddUserPoolClientSecretResponse$ = [3, n0, _AUPCSRd,
    0,
    [_CSD],
    [[() => ClientSecretDescriptorType$, 0]]
];
var AdminAddUserToGroupRequest$ = [3, n0, _AAUTGR,
    0,
    [_UPI, _U, _GN],
    [0, [() => UsernameType, 0], 0], 3
];
var AdminConfirmSignUpRequest$ = [3, n0, _ACSUR,
    0,
    [_UPI, _U, _CM],
    [0, [() => UsernameType, 0], 128 | 0], 2
];
var AdminConfirmSignUpResponse$ = [3, n0, _ACSURd,
    0,
    [],
    []
];
var AdminCreateUserConfigType$ = [3, n0, _ACUCT,
    0,
    [_AACUO, _UAVD, _IMT],
    [2, 1, () => MessageTemplateType$]
];
var AdminCreateUserRequest$ = [3, n0, _ACUR,
    0,
    [_UPI, _U, _UA, _VD, _TP, _FAC, _MAe, _DDM, _CM],
    [0, [() => UsernameType, 0], [() => AttributeListType, 0], [() => AttributeListType, 0], [() => PasswordType, 0], 2, 0, 64 | 0, 128 | 0], 2
];
var AdminCreateUserResponse$ = [3, n0, _ACURd,
    0,
    [_Us],
    [[() => UserType$, 0]]
];
var AdminDeleteSoftwareTokenRequest$ = [3, n0, _ADSTR,
    0,
    [_UPI, _U],
    [0, [() => UsernameType, 0]], 2
];
var AdminDeleteSoftwareTokenResponse$ = [3, n0, _ADSTRd,
    0,
    [],
    []
];
var AdminDeleteUserAttributesRequest$ = [3, n0, _ADUAR,
    0,
    [_UPI, _U, _UAN],
    [0, [() => UsernameType, 0], 64 | 0], 3
];
var AdminDeleteUserAttributesResponse$ = [3, n0, _ADUARd,
    0,
    [],
    []
];
var AdminDeleteUserRequest$ = [3, n0, _ADUR,
    0,
    [_UPI, _U],
    [0, [() => UsernameType, 0]], 2
];
var AdminDisableProviderForUserRequest$ = [3, n0, _ADPFUR,
    0,
    [_UPI, _Us],
    [0, () => ProviderUserIdentifierType$], 2
];
var AdminDisableProviderForUserResponse$ = [3, n0, _ADPFURd,
    0,
    [],
    []
];
var AdminDisableUserRequest$ = [3, n0, _ADURd,
    0,
    [_UPI, _U],
    [0, [() => UsernameType, 0]], 2
];
var AdminDisableUserResponse$ = [3, n0, _ADURdm,
    0,
    [],
    []
];
var AdminEnableUserRequest$ = [3, n0, _AEUR,
    0,
    [_UPI, _U],
    [0, [() => UsernameType, 0]], 2
];
var AdminEnableUserResponse$ = [3, n0, _AEURd,
    0,
    [],
    []
];
var AdminForgetDeviceRequest$ = [3, n0, _AFDR,
    0,
    [_UPI, _U, _DK],
    [0, [() => UsernameType, 0], 0], 3
];
var AdminGetDeviceRequest$ = [3, n0, _AGDR,
    0,
    [_DK, _UPI, _U],
    [0, 0, [() => UsernameType, 0]], 3
];
var AdminGetDeviceResponse$ = [3, n0, _AGDRd,
    0,
    [_D],
    [[() => DeviceType$, 0]], 1
];
var AdminGetUserAuthFactorsRequest$ = [3, n0, _AGUAFR,
    0,
    [_UPI, _U],
    [0, [() => UsernameType, 0]], 2
];
var AdminGetUserAuthFactorsResponse$ = [3, n0, _AGUAFRd,
    0,
    [_U, _PMS, _UMFASL, _CUAF],
    [[() => UsernameType, 0], 0, 64 | 0, 64 | 0], 1
];
var AdminGetUserRequest$ = [3, n0, _AGUR,
    0,
    [_UPI, _U],
    [0, [() => UsernameType, 0]], 2
];
var AdminGetUserResponse$ = [3, n0, _AGURd,
    0,
    [_U, _UA, _UCD, _ULMD, _E, _US, _MFAO, _PMS, _UMFASL],
    [[() => UsernameType, 0], [() => AttributeListType, 0], 4, 4, 2, 0, () => MFAOptionListType, 0, 64 | 0], 1
];
var AdminInitiateAuthRequest$ = [3, n0, _AIAR,
    0,
    [_UPI, _CI, _AF, _AP, _CM, _AM, _CD, _S],
    [0, [() => ClientIdType, 0], 0, [() => AuthParametersType, 0], 128 | 0, () => AnalyticsMetadataType$, () => ContextDataType$, [() => SessionType, 0]], 3
];
var AdminInitiateAuthResponse$ = [3, n0, _AIARd,
    0,
    [_CN, _S, _CP, _AR, _AC],
    [0, [() => SessionType, 0], 128 | 0, [() => AuthenticationResultType$, 0], 64 | 0]
];
var AdminLinkProviderForUserRequest$ = [3, n0, _ALPFUR,
    0,
    [_UPI, _DU, _SU],
    [0, () => ProviderUserIdentifierType$, () => ProviderUserIdentifierType$], 3
];
var AdminLinkProviderForUserResponse$ = [3, n0, _ALPFURd,
    0,
    [],
    []
];
var AdminListDevicesRequest$ = [3, n0, _ALDR,
    0,
    [_UPI, _U, _L, _PTa],
    [0, [() => UsernameType, 0], 1, 0], 2
];
var AdminListDevicesResponse$ = [3, n0, _ALDRd,
    0,
    [_De, _PTa],
    [[() => DeviceListType, 0], 0]
];
var AdminListGroupsForUserRequest$ = [3, n0, _ALGFUR,
    0,
    [_U, _UPI, _L, _NT],
    [[() => UsernameType, 0], 0, 1, 0], 2
];
var AdminListGroupsForUserResponse$ = [3, n0, _ALGFURd,
    0,
    [_G, _NT],
    [() => GroupListType, 0]
];
var AdminListUserAuthEventsRequest$ = [3, n0, _ALUAER,
    0,
    [_UPI, _U, _MR, _NT],
    [0, [() => UsernameType, 0], 1, 0], 2
];
var AdminListUserAuthEventsResponse$ = [3, n0, _ALUAERd,
    0,
    [_AE, _NT],
    [() => AuthEventsType, 0]
];
var AdminRemoveUserFromGroupRequest$ = [3, n0, _ARUFGR,
    0,
    [_UPI, _U, _GN],
    [0, [() => UsernameType, 0], 0], 3
];
var AdminResetUserPasswordRequest$ = [3, n0, _ARUPR,
    0,
    [_UPI, _U, _CM],
    [0, [() => UsernameType, 0], 128 | 0], 2
];
var AdminResetUserPasswordResponse$ = [3, n0, _ARUPRd,
    0,
    [],
    []
];
var AdminRespondToAuthChallengeRequest$ = [3, n0, _ARTACR,
    0,
    [_UPI, _CI, _CN, _CR, _S, _AM, _CD, _CM],
    [0, [() => ClientIdType, 0], 0, [() => ChallengeResponsesType, 0], [() => SessionType, 0], () => AnalyticsMetadataType$, () => ContextDataType$, 128 | 0], 3
];
var AdminRespondToAuthChallengeResponse$ = [3, n0, _ARTACRd,
    0,
    [_CN, _S, _CP, _AR],
    [0, [() => SessionType, 0], 128 | 0, [() => AuthenticationResultType$, 0]]
];
var AdminSetUserMFAPreferenceRequest$ = [3, n0, _ASUMFAPR,
    0,
    [_U, _UPI, _SMSMS, _STMS, _EMS, _WAMS],
    [[() => UsernameType, 0], 0, () => SMSMfaSettingsType$, () => SoftwareTokenMfaSettingsType$, () => EmailMfaSettingsType$, () => WebAuthnMfaSettingsType$], 2
];
var AdminSetUserMFAPreferenceResponse$ = [3, n0, _ASUMFAPRd,
    0,
    [],
    []
];
var AdminSetUserPasswordRequest$ = [3, n0, _ASUPR,
    0,
    [_UPI, _U, _P, _Pe],
    [0, [() => UsernameType, 0], [() => PasswordType, 0], 2], 3
];
var AdminSetUserPasswordResponse$ = [3, n0, _ASUPRd,
    0,
    [],
    []
];
var AdminSetUserSettingsRequest$ = [3, n0, _ASUSR,
    0,
    [_UPI, _U, _MFAO],
    [0, [() => UsernameType, 0], () => MFAOptionListType], 3
];
var AdminSetUserSettingsResponse$ = [3, n0, _ASUSRd,
    0,
    [],
    []
];
var AdminUpdateAuthEventFeedbackRequest$ = [3, n0, _AUAEFR,
    0,
    [_UPI, _U, _EI, _FV],
    [0, [() => UsernameType, 0], 0, 0], 4
];
var AdminUpdateAuthEventFeedbackResponse$ = [3, n0, _AUAEFRd,
    0,
    [],
    []
];
var AdminUpdateDeviceStatusRequest$ = [3, n0, _AUDSR,
    0,
    [_UPI, _U, _DK, _DRS],
    [0, [() => UsernameType, 0], 0, 0], 3
];
var AdminUpdateDeviceStatusResponse$ = [3, n0, _AUDSRd,
    0,
    [],
    []
];
var AdminUpdateUserAttributesRequest$ = [3, n0, _AUUAR,
    0,
    [_UPI, _U, _UA, _CM],
    [0, [() => UsernameType, 0], [() => AttributeListType, 0], 128 | 0], 3
];
var AdminUpdateUserAttributesResponse$ = [3, n0, _AUUARd,
    0,
    [],
    []
];
var AdminUserGlobalSignOutRequest$ = [3, n0, _AUGSOR,
    0,
    [_UPI, _U],
    [0, [() => UsernameType, 0]], 2
];
var AdminUserGlobalSignOutResponse$ = [3, n0, _AUGSORd,
    0,
    [],
    []
];
var AdvancedSecurityAdditionalFlowsType$ = [3, n0, _ASAFT,
    0,
    [_CAM],
    [0]
];
var AnalyticsConfigurationType$ = [3, n0, _ACT,
    0,
    [_AI, _AA, _RA, _EIx, _UDS],
    [0, 0, 0, 0, 2]
];
var AnalyticsMetadataType$ = [3, n0, _AMT,
    0,
    [_AEI],
    [0]
];
var AssetType$ = [3, n0, _AT,
    0,
    [_C, _CMo, _Ex, _B, _RI],
    [0, 0, 0, 21, 0], 3
];
var AssociateSoftwareTokenRequest$ = [3, n0, _ASTR,
    0,
    [_ATc, _S],
    [[() => TokenModelType, 0], [() => SessionType, 0]]
];
var AssociateSoftwareTokenResponse$ = [3, n0, _ASTRs,
    0,
    [_SC, _S],
    [[() => SecretCodeType, 0], [() => SessionType, 0]]
];
var AttributeType$ = [3, n0, _ATt,
    0,
    [_Na, _V],
    [0, [() => AttributeValueType, 0]], 1
];
var AuthenticationResultType$ = [3, n0, _ART,
    0,
    [_ATc, _EIxp, _TT, _RT, _IT, _NDM],
    [[() => TokenModelType, 0], 1, 0, [() => TokenModelType, 0], [() => TokenModelType, 0], () => NewDeviceMetadataType$]
];
var AuthEventType$ = [3, n0, _AET,
    0,
    [_EI, _ET, _CDr, _ER, _ERv, _CR, _ECD, _EF],
    [0, 0, 4, 0, () => EventRiskType$, () => ChallengeResponseListType, () => EventContextDataType$, () => EventFeedbackType$]
];
var ChallengeResponseType$ = [3, n0, _CRT,
    0,
    [_CN, _CRh],
    [0, 0]
];
var ChangePasswordRequest$ = [3, n0, _CPR,
    0,
    [_PP, _ATc, _PPr],
    [[() => PasswordType, 0], [() => TokenModelType, 0], [() => PasswordType, 0]], 2
];
var ChangePasswordResponse$ = [3, n0, _CPRh,
    0,
    [],
    []
];
var ClientAuthenticationResultType$ = [3, n0, _CART,
    0,
    [_ATc, _EIxp, _TT],
    [[() => TokenModelType, 0], 1, 0]
];
var ClientSecretDescriptorType$ = [3, n0, _CSDT,
    0,
    [_CSI, _CSV, _CSCD],
    [0, [() => ClientSecretType, 0], 4]
];
var CloudWatchLogsConfigurationType$ = [3, n0, _CWLCT,
    0,
    [_LGA],
    [0]
];
var CodeDeliveryDetailsType$ = [3, n0, _CDDT,
    0,
    [_Des, _DM, _AN],
    [0, 0, 0]
];
var CompleteWebAuthnRegistrationRequest$ = [3, n0, _CWARR,
    0,
    [_ATc, _Cr],
    [[() => TokenModelType, 0], 15], 2
];
var CompleteWebAuthnRegistrationResponse$ = [3, n0, _CWARRo,
    0,
    [],
    []
];
var CompromisedCredentialsActionsType$ = [3, n0, _CCAT,
    0,
    [_EA],
    [0], 1
];
var CompromisedCredentialsRiskConfigurationType$ = [3, n0, _CCRCT,
    0,
    [_A, _EFv],
    [() => CompromisedCredentialsActionsType$, 64 | 0], 1
];
var ConfirmDeviceRequest$ = [3, n0, _CDR,
    0,
    [_ATc, _DK, _DSVC, _DN],
    [[() => TokenModelType, 0], 0, () => DeviceSecretVerifierConfigType$, 0], 2
];
var ConfirmDeviceResponse$ = [3, n0, _CDRo,
    0,
    [_UCN],
    [2]
];
var ConfirmForgotPasswordRequest$ = [3, n0, _CFPR,
    0,
    [_CI, _U, _CC, _P, _SH, _AM, _UCDs, _CM],
    [[() => ClientIdType, 0], [() => UsernameType, 0], 0, [() => PasswordType, 0], [() => SecretHashType, 0], () => AnalyticsMetadataType$, [() => UserContextDataType$, 0], 128 | 0], 4
];
var ConfirmForgotPasswordResponse$ = [3, n0, _CFPRo,
    0,
    [],
    []
];
var ConfirmSignUpRequest$ = [3, n0, _CSUR,
    0,
    [_CI, _U, _CC, _SH, _FAC, _AM, _UCDs, _CM, _S],
    [[() => ClientIdType, 0], [() => UsernameType, 0], 0, [() => SecretHashType, 0], 2, () => AnalyticsMetadataType$, [() => UserContextDataType$, 0], 128 | 0, [() => SessionType, 0]], 3
];
var ConfirmSignUpResponse$ = [3, n0, _CSURo,
    0,
    [_S],
    [[() => SessionType, 0]]
];
var ContextDataType$ = [3, n0, _CDT,
    0,
    [_IA, _SN, _SP, _HH, _ED],
    [0, 0, 0, () => HttpHeaderList, 0], 4
];
var CreateGroupRequest$ = [3, n0, _CGR,
    0,
    [_GN, _UPI, _Desc, _RA, _Pr],
    [0, 0, 0, 0, 1], 2
];
var CreateGroupResponse$ = [3, n0, _CGRr,
    0,
    [_Gr],
    [() => GroupType$]
];
var CreateIdentityProviderRequest$ = [3, n0, _CIPR,
    0,
    [_UPI, _PN, _PTr, _PD, _AMt, _II],
    [0, 0, 0, 128 | 0, 128 | 0, 64 | 0], 4
];
var CreateIdentityProviderResponse$ = [3, n0, _CIPRr,
    0,
    [_IP],
    [() => IdentityProviderType$], 1
];
var CreateManagedLoginBrandingRequest$ = [3, n0, _CMLBR,
    0,
    [_UPI, _CI, _UCPV, _Se, _As],
    [0, [() => ClientIdType, 0], 2, 15, () => AssetListType], 2
];
var CreateManagedLoginBrandingResponse$ = [3, n0, _CMLBRr,
    0,
    [_MLB],
    [() => ManagedLoginBrandingType$]
];
var CreateResourceServerRequest$ = [3, n0, _CRSR,
    0,
    [_UPI, _I, _Na, _Sc],
    [0, 0, 0, () => ResourceServerScopeListType], 3
];
var CreateResourceServerResponse$ = [3, n0, _CRSRr,
    0,
    [_RS],
    [() => ResourceServerType$], 1
];
var CreateTermsRequest$ = [3, n0, _CTR,
    0,
    [_UPI, _CI, _TN, _TS, _En, _Li],
    [0, [() => ClientIdType, 0], 0, 0, 0, 128 | 0], 5
];
var CreateTermsResponse$ = [3, n0, _CTRr,
    0,
    [_T],
    [[() => TermsType$, 0]]
];
var CreateUserImportJobRequest$ = [3, n0, _CUIJR,
    0,
    [_JN, _UPI, _CWLRA, _PHA],
    [0, 0, 0, 0], 3
];
var CreateUserImportJobResponse$ = [3, n0, _CUIJRr,
    0,
    [_UIJ],
    [() => UserImportJobType$]
];
var CreateUserPoolClientRequest$ = [3, n0, _CUPCR,
    0,
    [_UPI, _CNl, _GS, _CS, _RTV, _ATV, _ITV, _TVU, _RAe, _WA, _EAF, _SIP, _CURL, _LURL, _DRURI, _AOAF, _AOAS, _AOAFUPC, _ACn, _PUEE, _ETR, _EPAUCD, _ASV, _RTR],
    [0, 0, 2, [() => ClientSecretType, 0], 1, 1, 1, () => TokenValidityUnitsType$, 64 | 0, 64 | 0, 64 | 0, 64 | 0, 64 | 0, 64 | 0, 0, 64 | 0, 64 | 0, 2, () => AnalyticsConfigurationType$, 0, 2, 2, 1, () => RefreshTokenRotationType$], 2
];
var CreateUserPoolClientResponse$ = [3, n0, _CUPCRr,
    0,
    [_UPC],
    [[() => UserPoolClientType$, 0]]
];
var CreateUserPoolDomainRequest$ = [3, n0, _CUPDR,
    0,
    [_Do, _UPI, _MLV, _CDC, _R],
    [0, 0, 1, () => CustomDomainConfigType$, () => RoutingType$], 2
];
var CreateUserPoolDomainResponse$ = [3, n0, _CUPDRr,
    0,
    [_MLV, _CFD, _R],
    [1, 0, () => RoutingType$]
];
var CreateUserPoolReplicaRequest$ = [3, n0, _CUPRR,
    0,
    [_UPI, _RN, _UPT],
    [0, 0, 128 | 0], 2
];
var CreateUserPoolReplicaResponse$ = [3, n0, _CUPRRr,
    0,
    [_UPR],
    [() => UserPoolReplicaType$]
];
var CreateUserPoolRequest$ = [3, n0, _CUPR,
    0,
    [_PNo, _Po, _DP, _LC, _AVA, _AAl, _UAs, _SVM, _EVM, _EVS, _VMT, _SAM, _MC, _UAUS, _DC, _EC, _SCm, _UPT, _ACUC, _Sch, _UPAO, _UC, _ARS, _UPTs, _KC, _IC],
    [0, () => UserPoolPolicyType$, 0, () => LambdaConfigType$, 64 | 0, 64 | 0, 64 | 0, 0, 0, 0, () => VerificationMessageTemplateType$, 0, 0, () => UserAttributeUpdateSettingsType$, () => DeviceConfigurationType$, () => EmailConfigurationType$, () => SmsConfigurationType$, 128 | 0, () => AdminCreateUserConfigType$, () => SchemaAttributesListType, () => UserPoolAddOnsType$, () => UsernameConfigurationType$, () => AccountRecoverySettingType$, 0, () => KeyConfigurationType$, () => IssuerConfigurationType$], 1
];
var CreateUserPoolResponse$ = [3, n0, _CUPRr,
    0,
    [_UP],
    [() => UserPoolType$]
];
var CustomDomainConfigType$ = [3, n0, _CDCT,
    0,
    [_CAe, _SPe],
    [0, 0], 1
];
var CustomEmailLambdaVersionConfigType$ = [3, n0, _CELVCT,
    0,
    [_LV, _LAa],
    [0, 0], 2
];
var CustomSMSLambdaVersionConfigType$ = [3, n0, _CSMSLVCT,
    0,
    [_LV, _LAa],
    [0, 0], 2
];
var DeleteGroupRequest$ = [3, n0, _DGR,
    0,
    [_GN, _UPI],
    [0, 0], 2
];
var DeleteIdentityProviderRequest$ = [3, n0, _DIPR,
    0,
    [_UPI, _PN],
    [0, 0], 2
];
var DeleteManagedLoginBrandingRequest$ = [3, n0, _DMLBR,
    0,
    [_MLBI, _UPI],
    [0, 0], 2
];
var DeleteResourceServerRequest$ = [3, n0, _DRSR,
    0,
    [_UPI, _I],
    [0, 0], 2
];
var DeleteTermsRequest$ = [3, n0, _DTR,
    0,
    [_TI, _UPI],
    [0, 0], 2
];
var DeleteUserAttributesRequest$ = [3, n0, _DUAR,
    0,
    [_UAN, _ATc],
    [64 | 0, [() => TokenModelType, 0]], 2
];
var DeleteUserAttributesResponse$ = [3, n0, _DUARe,
    0,
    [],
    []
];
var DeleteUserPoolClientRequest$ = [3, n0, _DUPCR,
    0,
    [_UPI, _CI],
    [0, [() => ClientIdType, 0]], 2
];
var DeleteUserPoolClientSecretRequest$ = [3, n0, _DUPCSR,
    0,
    [_UPI, _CI, _CSI],
    [0, [() => ClientIdType, 0], 0], 3
];
var DeleteUserPoolClientSecretResponse$ = [3, n0, _DUPCSRe,
    0,
    [],
    []
];
var DeleteUserPoolDomainRequest$ = [3, n0, _DUPDR,
    0,
    [_Do, _UPI],
    [0, 0], 2
];
var DeleteUserPoolDomainResponse$ = [3, n0, _DUPDRe,
    0,
    [],
    []
];
var DeleteUserPoolReplicaRequest$ = [3, n0, _DUPRR,
    0,
    [_UPI, _RN],
    [0, 0], 2
];
var DeleteUserPoolReplicaResponse$ = [3, n0, _DUPRRe,
    0,
    [_UPR],
    [() => UserPoolReplicaType$]
];
var DeleteUserPoolRequest$ = [3, n0, _DUPR,
    0,
    [_UPI],
    [0], 1
];
var DeleteUserRequest$ = [3, n0, _DUR,
    0,
    [_ATc],
    [[() => TokenModelType, 0]], 1
];
var DeleteWebAuthnCredentialRequest$ = [3, n0, _DWACR,
    0,
    [_ATc, _CIr],
    [[() => TokenModelType, 0], 0], 2
];
var DeleteWebAuthnCredentialResponse$ = [3, n0, _DWACRe,
    0,
    [],
    []
];
var DescribeIdentityProviderRequest$ = [3, n0, _DIPRe,
    0,
    [_UPI, _PN],
    [0, 0], 2
];
var DescribeIdentityProviderResponse$ = [3, n0, _DIPRes,
    0,
    [_IP],
    [() => IdentityProviderType$], 1
];
var DescribeManagedLoginBrandingByClientRequest$ = [3, n0, _DMLBBCR,
    0,
    [_UPI, _CI, _RMR],
    [0, [() => ClientIdType, 0], 2], 2
];
var DescribeManagedLoginBrandingByClientResponse$ = [3, n0, _DMLBBCRe,
    0,
    [_MLB],
    [() => ManagedLoginBrandingType$]
];
var DescribeManagedLoginBrandingRequest$ = [3, n0, _DMLBRe,
    0,
    [_UPI, _MLBI, _RMR],
    [0, 0, 2], 2
];
var DescribeManagedLoginBrandingResponse$ = [3, n0, _DMLBRes,
    0,
    [_MLB],
    [() => ManagedLoginBrandingType$]
];
var DescribeResourceServerRequest$ = [3, n0, _DRSRe,
    0,
    [_UPI, _I],
    [0, 0], 2
];
var DescribeResourceServerResponse$ = [3, n0, _DRSRes,
    0,
    [_RS],
    [() => ResourceServerType$], 1
];
var DescribeRiskConfigurationRequest$ = [3, n0, _DRCR,
    0,
    [_UPI, _CI],
    [0, [() => ClientIdType, 0]], 1
];
var DescribeRiskConfigurationResponse$ = [3, n0, _DRCRe,
    0,
    [_RC],
    [[() => RiskConfigurationType$, 0]], 1
];
var DescribeTermsByClientRequest$ = [3, n0, _DTBCR,
    0,
    [_CI, _UPI, _TN],
    [[() => ClientIdType, 0], 0, 0], 3
];
var DescribeTermsByClientResponse$ = [3, n0, _DTBCRe,
    0,
    [_T],
    [[() => TermsType$, 0]]
];
var DescribeTermsRequest$ = [3, n0, _DTRe,
    0,
    [_TI, _UPI],
    [0, 0], 2
];
var DescribeTermsResponse$ = [3, n0, _DTRes,
    0,
    [_T],
    [[() => TermsType$, 0]]
];
var DescribeUserImportJobRequest$ = [3, n0, _DUIJR,
    0,
    [_UPI, _JI],
    [0, 0], 2
];
var DescribeUserImportJobResponse$ = [3, n0, _DUIJRe,
    0,
    [_UIJ],
    [() => UserImportJobType$]
];
var DescribeUserPoolClientRequest$ = [3, n0, _DUPCRe,
    0,
    [_UPI, _CI],
    [0, [() => ClientIdType, 0]], 2
];
var DescribeUserPoolClientResponse$ = [3, n0, _DUPCRes,
    0,
    [_UPC],
    [[() => UserPoolClientType$, 0]]
];
var DescribeUserPoolDomainRequest$ = [3, n0, _DUPDRes,
    0,
    [_Do],
    [0], 1
];
var DescribeUserPoolDomainResponse$ = [3, n0, _DUPDResc,
    0,
    [_DD],
    [() => DomainDescriptionType$]
];
var DescribeUserPoolRequest$ = [3, n0, _DUPRe,
    0,
    [_UPI],
    [0], 1
];
var DescribeUserPoolResponse$ = [3, n0, _DUPRes,
    0,
    [_UP],
    [() => UserPoolType$]
];
var DeviceConfigurationType$ = [3, n0, _DCT,
    0,
    [_CROND, _DOROUP],
    [2, 2]
];
var DeviceSecretVerifierConfigType$ = [3, n0, _DSVCT,
    0,
    [_PV, _Sa],
    [0, 0]
];
var DeviceType$ = [3, n0, _DT,
    0,
    [_DK, _DA, _DCD, _DLMD, _DLAD],
    [0, [() => AttributeListType, 0], 4, 4, 4]
];
var DomainDescriptionType$ = [3, n0, _DDT,
    0,
    [_UPI, _AWSAI, _Do, _SB, _CFDl, _Ve, _St, _CDC, _MLV, _R],
    [0, 0, 0, 0, 0, 0, 0, () => CustomDomainConfigType$, 1, () => RoutingType$]
];
var EmailConfigurationType$ = [3, n0, _ECT,
    0,
    [_SA, _RTEA, _ESA, _F, _CSo],
    [0, 0, 0, 0, 0]
];
var EmailMfaConfigType$ = [3, n0, _EMCT,
    0,
    [_M, _Su],
    [0, 0]
];
var EmailMfaSettingsType$ = [3, n0, _EMST,
    0,
    [_E, _PM],
    [2, 2]
];
var EumsSmsConfigurationType$ = [3, n0, _ESCT,
    0,
    [_CAa, _EIx, _OI, _CSN, _IEI, _ITI, _Re],
    [0, 0, 0, 0, 0, 0, 0], 1
];
var EventContextDataType$ = [3, n0, _ECDT,
    0,
    [_IA, _DN, _Ti, _Ci, _Co],
    [0, 0, 0, 0, 0]
];
var EventFeedbackType$ = [3, n0, _EFT,
    0,
    [_FV, _Pro, _FD],
    [0, 0, 4], 2
];
var EventRiskType$ = [3, n0, _ERT,
    0,
    [_RD, _RL, _CCD],
    [0, 0, 2]
];
var FailoverType$ = [3, n0, _FT,
    0,
    [_SR, _PRHCI],
    [0, 0], 2
];
var FirehoseConfigurationType$ = [3, n0, _FCT,
    0,
    [_SAt],
    [0]
];
var ForgetDeviceRequest$ = [3, n0, _FDR,
    0,
    [_DK, _ATc],
    [0, [() => TokenModelType, 0]], 1
];
var ForgotPasswordRequest$ = [3, n0, _FPR,
    0,
    [_CI, _U, _SH, _UCDs, _AM, _CM],
    [[() => ClientIdType, 0], [() => UsernameType, 0], [() => SecretHashType, 0], [() => UserContextDataType$, 0], () => AnalyticsMetadataType$, 128 | 0], 2
];
var ForgotPasswordResponse$ = [3, n0, _FPRo,
    0,
    [_CDD],
    [() => CodeDeliveryDetailsType$]
];
var GetClientTokenRequest$ = [3, n0, _GCTR,
    0,
    [_CI, _Sec, _Sc, _CM],
    [[() => ClientIdType, 0], [() => ClientSecretType, 0], 64 | 0, 128 | 0], 2
];
var GetClientTokenResponse$ = [3, n0, _GCTRe,
    0,
    [_CAR],
    [[() => ClientAuthenticationResultType$, 0]]
];
var GetCSVHeaderRequest$ = [3, n0, _GCSVHR,
    0,
    [_UPI],
    [0], 1
];
var GetCSVHeaderResponse$ = [3, n0, _GCSVHRe,
    0,
    [_UPI, _CSVH],
    [0, 64 | 0]
];
var GetDeviceRequest$ = [3, n0, _GDR,
    0,
    [_DK, _ATc],
    [0, [() => TokenModelType, 0]], 1
];
var GetDeviceResponse$ = [3, n0, _GDRe,
    0,
    [_D],
    [[() => DeviceType$, 0]], 1
];
var GetGroupRequest$ = [3, n0, _GGR,
    0,
    [_GN, _UPI],
    [0, 0], 2
];
var GetGroupResponse$ = [3, n0, _GGRe,
    0,
    [_Gr],
    [() => GroupType$]
];
var GetIdentityProviderByIdentifierRequest$ = [3, n0, _GIPBIR,
    0,
    [_UPI, _IId],
    [0, 0], 2
];
var GetIdentityProviderByIdentifierResponse$ = [3, n0, _GIPBIRe,
    0,
    [_IP],
    [() => IdentityProviderType$], 1
];
var GetLogDeliveryConfigurationRequest$ = [3, n0, _GLDCR,
    0,
    [_UPI],
    [0], 1
];
var GetLogDeliveryConfigurationResponse$ = [3, n0, _GLDCRe,
    0,
    [_LDC],
    [() => LogDeliveryConfigurationType$]
];
var GetProvisionedLimitRequest$ = [3, n0, _GPLR,
    0,
    [_LD],
    [() => LimitDefinitionType$], 1
];
var GetProvisionedLimitResponse$ = [3, n0, _GPLRe,
    0,
    [_L],
    [() => LimitType$], 1
];
var GetSigningCertificateRequest$ = [3, n0, _GSCR,
    0,
    [_UPI],
    [0], 1
];
var GetSigningCertificateResponse$ = [3, n0, _GSCRe,
    0,
    [_Ce],
    [0]
];
var GetTokensFromRefreshTokenRequest$ = [3, n0, _GTFRTR,
    0,
    [_RT, _CI, _CS, _DK, _CM],
    [[() => TokenModelType, 0], [() => ClientIdType, 0], [() => ClientSecretType, 0], 0, 128 | 0], 2
];
var GetTokensFromRefreshTokenResponse$ = [3, n0, _GTFRTRe,
    0,
    [_AR],
    [[() => AuthenticationResultType$, 0]]
];
var GetUICustomizationRequest$ = [3, n0, _GUICR,
    0,
    [_UPI, _CI],
    [0, [() => ClientIdType, 0]], 1
];
var GetUICustomizationResponse$ = [3, n0, _GUICRe,
    0,
    [_UIC],
    [[() => UICustomizationType$, 0]], 1
];
var GetUserAttributeVerificationCodeRequest$ = [3, n0, _GUAVCR,
    0,
    [_ATc, _AN, _CM],
    [[() => TokenModelType, 0], 0, 128 | 0], 2
];
var GetUserAttributeVerificationCodeResponse$ = [3, n0, _GUAVCRe,
    0,
    [_CDD],
    [() => CodeDeliveryDetailsType$]
];
var GetUserAuthFactorsRequest$ = [3, n0, _GUAFR,
    0,
    [_ATc],
    [[() => TokenModelType, 0]], 1
];
var GetUserAuthFactorsResponse$ = [3, n0, _GUAFRe,
    0,
    [_U, _PMS, _UMFASL, _CUAF],
    [[() => UsernameType, 0], 0, 64 | 0, 64 | 0], 1
];
var GetUserPoolMfaConfigRequest$ = [3, n0, _GUPMCR,
    0,
    [_UPI],
    [0], 1
];
var GetUserPoolMfaConfigResponse$ = [3, n0, _GUPMCRe,
    0,
    [_SMC, _STMC, _EMC, _MC, _WAC],
    [() => SmsMfaConfigType$, () => SoftwareTokenMfaConfigType$, () => EmailMfaConfigType$, 0, () => WebAuthnConfigurationType$]
];
var GetUserRequest$ = [3, n0, _GUR,
    0,
    [_ATc],
    [[() => TokenModelType, 0]], 1
];
var GetUserResponse$ = [3, n0, _GURe,
    0,
    [_U, _UA, _MFAO, _PMS, _UMFASL],
    [[() => UsernameType, 0], [() => AttributeListType, 0], () => MFAOptionListType, 0, 64 | 0], 2
];
var GlobalSignOutRequest$ = [3, n0, _GSOR,
    0,
    [_ATc],
    [[() => TokenModelType, 0]], 1
];
var GlobalSignOutResponse$ = [3, n0, _GSORl,
    0,
    [],
    []
];
var GroupType$ = [3, n0, _GT,
    0,
    [_GN, _UPI, _Desc, _RA, _Pr, _LMD, _CDr],
    [0, 0, 0, 0, 1, 4, 4]
];
var HttpHeader$ = [3, n0, _HHt,
    0,
    [_hN, _hV],
    [0, 0]
];
var IdentityProviderType$ = [3, n0, _IPT,
    0,
    [_UPI, _PN, _PTr, _PD, _AMt, _II, _LMD, _CDr],
    [0, 0, 0, 128 | 0, 128 | 0, 64 | 0, 4, 4]
];
var InboundFederationLambdaType$ = [3, n0, _IFLT,
    0,
    [_LV, _LAa],
    [0, 0], 2
];
var InitiateAuthRequest$ = [3, n0, _IAR,
    0,
    [_AF, _CI, _AP, _CM, _AM, _UCDs, _S],
    [0, [() => ClientIdType, 0], [() => AuthParametersType, 0], 128 | 0, () => AnalyticsMetadataType$, [() => UserContextDataType$, 0], [() => SessionType, 0]], 2
];
var InitiateAuthResponse$ = [3, n0, _IARn,
    0,
    [_CN, _S, _CP, _AR, _AC],
    [0, [() => SessionType, 0], 128 | 0, [() => AuthenticationResultType$, 0], 64 | 0]
];
var IssuerConfigurationType$ = [3, n0, _ICT,
    0,
    [_Ty],
    [0]
];
var KeyConfigurationType$ = [3, n0, _KCT,
    0,
    [_KT, _KKA],
    [0, 0]
];
var LambdaConfigType$ = [3, n0, _LCT,
    0,
    [_PSU, _CMu, _PC, _PA, _PAo, _DAC, _CAC, _VACR, _PTG, _UM, _PTGC, _CSMSS, _CES, _KMSKID, _IF],
    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, () => PreTokenGenerationVersionConfigType$, () => CustomSMSLambdaVersionConfigType$, () => CustomEmailLambdaVersionConfigType$, 0, () => InboundFederationLambdaType$]
];
var LimitDefinitionType$ = [3, n0, _LDT,
    0,
    [_LCi, _At],
    [0, 128 | 0], 2
];
var LimitType$ = [3, n0, _LT,
    0,
    [_LD, _PLV, _FLV],
    [() => LimitDefinitionType$, 1, 1], 3
];
var ListDevicesRequest$ = [3, n0, _LDR,
    0,
    [_ATc, _L, _PTa],
    [[() => TokenModelType, 0], 1, 0], 1
];
var ListDevicesResponse$ = [3, n0, _LDRi,
    0,
    [_De, _PTa],
    [[() => DeviceListType, 0], 0]
];
var ListGroupsRequest$ = [3, n0, _LGR,
    0,
    [_UPI, _L, _NT],
    [0, 1, 0], 1
];
var ListGroupsResponse$ = [3, n0, _LGRi,
    0,
    [_G, _NT],
    [() => GroupListType, 0]
];
var ListIdentityProvidersRequest$ = [3, n0, _LIPR,
    0,
    [_UPI, _MR, _NT],
    [0, 1, 0], 1
];
var ListIdentityProvidersResponse$ = [3, n0, _LIPRi,
    0,
    [_Prov, _NT],
    [() => ProvidersListType, 0], 1
];
var ListResourceServersRequest$ = [3, n0, _LRSR,
    0,
    [_UPI, _MR, _NT],
    [0, 1, 0], 1
];
var ListResourceServersResponse$ = [3, n0, _LRSRi,
    0,
    [_RSe, _NT],
    [() => ResourceServersListType, 0], 1
];
var ListTagsForResourceRequest$ = [3, n0, _LTFRR,
    0,
    [_RAes],
    [0], 1
];
var ListTagsForResourceResponse$ = [3, n0, _LTFRRi,
    0,
    [_Ta],
    [128 | 0]
];
var ListTermsRequest$ = [3, n0, _LTR,
    0,
    [_UPI, _MR, _NT],
    [0, 1, 0], 1
];
var ListTermsResponse$ = [3, n0, _LTRi,
    0,
    [_T, _NT],
    [() => TermsDescriptionListType, 0], 1
];
var ListUserImportJobsRequest$ = [3, n0, _LUIJR,
    0,
    [_UPI, _MR, _PTa],
    [0, 1, 0], 2
];
var ListUserImportJobsResponse$ = [3, n0, _LUIJRi,
    0,
    [_UIJs, _PTa],
    [() => UserImportJobsListType, 0]
];
var ListUserPoolClientSecretsRequest$ = [3, n0, _LUPCSR,
    0,
    [_UPI, _CI, _NT],
    [0, [() => ClientIdType, 0], 0], 2
];
var ListUserPoolClientSecretsResponse$ = [3, n0, _LUPCSRi,
    0,
    [_CSl, _NT],
    [[() => ClientSecretDescriptorListType, 0], 0]
];
var ListUserPoolClientsRequest$ = [3, n0, _LUPCR,
    0,
    [_UPI, _MR, _NT],
    [0, 1, 0], 1
];
var ListUserPoolClientsResponse$ = [3, n0, _LUPCRi,
    0,
    [_UPCs, _NT],
    [[() => UserPoolClientListType, 0], 0]
];
var ListUserPoolReplicasRequest$ = [3, n0, _LUPRR,
    0,
    [_UPI, _NT],
    [0, 0], 1
];
var ListUserPoolReplicasResponse$ = [3, n0, _LUPRRi,
    0,
    [_UPRs, _NT],
    [() => UserPoolReplicaListType, 0]
];
var ListUserPoolsRequest$ = [3, n0, _LUPR,
    0,
    [_MR, _NT],
    [1, 0], 1
];
var ListUserPoolsResponse$ = [3, n0, _LUPRi,
    0,
    [_UPs, _NT],
    [() => UserPoolListType, 0]
];
var ListUsersInGroupRequest$ = [3, n0, _LUIGR,
    0,
    [_UPI, _GN, _L, _NT],
    [0, 0, 1, 0], 2
];
var ListUsersInGroupResponse$ = [3, n0, _LUIGRi,
    0,
    [_Use, _NT],
    [[() => UsersListType, 0], 0]
];
var ListUsersRequest$ = [3, n0, _LUR,
    0,
    [_UPI, _ATG, _L, _PTa, _Fi],
    [0, 64 | 0, 1, 0, 0], 1
];
var ListUsersResponse$ = [3, n0, _LURi,
    0,
    [_Use, _PTa],
    [[() => UsersListType, 0], 0]
];
var ListWebAuthnCredentialsRequest$ = [3, n0, _LWACR,
    0,
    [_ATc, _NT, _MR],
    [[() => TokenModelType, 0], 0, 1], 1
];
var ListWebAuthnCredentialsResponse$ = [3, n0, _LWACRi,
    0,
    [_Cre, _NT],
    [() => WebAuthnCredentialDescriptionListType, 0], 1
];
var LogConfigurationType$ = [3, n0, _LCTo,
    0,
    [_LL, _ES, _CWLC, _SCo, _FC],
    [0, 0, () => CloudWatchLogsConfigurationType$, () => S3ConfigurationType$, () => FirehoseConfigurationType$], 2
];
var LogDeliveryConfigurationType$ = [3, n0, _LDCT,
    0,
    [_UPI, _LCo],
    [0, () => LogConfigurationListType], 2
];
var ManagedLoginBrandingType$ = [3, n0, _MLBT,
    0,
    [_MLBI, _UPI, _UCPV, _Se, _As, _CDr, _LMD],
    [0, 0, 2, 15, () => AssetListType, 4, 4]
];
var MessageTemplateType$ = [3, n0, _MTT,
    0,
    [_SMSM, _EM, _ESm],
    [0, 0, 0]
];
var MFAOptionType$ = [3, n0, _MFAOT,
    0,
    [_DM, _AN],
    [0, 0]
];
var NewDeviceMetadataType$ = [3, n0, _NDMT,
    0,
    [_DK, _DGK],
    [0, 0]
];
var NotifyConfigurationType$ = [3, n0, _NCT,
    0,
    [_SA, _F, _RTe, _BE, _NAEo, _ME],
    [0, 0, 0, () => NotifyEmailType$, () => NotifyEmailType$, () => NotifyEmailType$], 1
];
var NotifyEmailType$ = [3, n0, _NET,
    0,
    [_Su, _HB, _TB],
    [0, 0, 0], 1
];
var NumberAttributeConstraintsType$ = [3, n0, _NACT,
    0,
    [_MV, _MVa],
    [0, 0]
];
var PasswordPolicyType$ = [3, n0, _PPT,
    0,
    [_ML, _RU, _RLe, _RNe, _RSeq, _PHS, _TPVD],
    [1, 2, 2, 2, 2, 1, 1]
];
var PreTokenGenerationVersionConfigType$ = [3, n0, _PTGVCT,
    0,
    [_LV, _LAa],
    [0, 0], 2
];
var ProviderDescription$ = [3, n0, _PDr,
    0,
    [_PN, _PTr, _LMD, _CDr],
    [0, 0, 4, 4]
];
var ProviderUserIdentifierType$ = [3, n0, _PUIT,
    0,
    [_PN, _PAN, _PAV],
    [0, 0, 0]
];
var RecoveryOptionType$ = [3, n0, _ROT,
    0,
    [_Pri, _Na],
    [1, 0], 2
];
var RefreshTokenRotationType$ = [3, n0, _RTRT,
    0,
    [_Fe, _RGPS],
    [0, 1], 1
];
var ResendConfirmationCodeRequest$ = [3, n0, _RCCR,
    0,
    [_CI, _U, _SH, _UCDs, _AM, _CM],
    [[() => ClientIdType, 0], [() => UsernameType, 0], [() => SecretHashType, 0], [() => UserContextDataType$, 0], () => AnalyticsMetadataType$, 128 | 0], 2
];
var ResendConfirmationCodeResponse$ = [3, n0, _RCCRe,
    0,
    [_CDD],
    [() => CodeDeliveryDetailsType$]
];
var ResourceServerScopeType$ = [3, n0, _RSST,
    0,
    [_SNc, _SD],
    [0, 0], 2
];
var ResourceServerType$ = [3, n0, _RST,
    0,
    [_UPI, _I, _Na, _Sc],
    [0, 0, 0, () => ResourceServerScopeListType]
];
var RespondToAuthChallengeRequest$ = [3, n0, _RTACR,
    0,
    [_CI, _CN, _S, _CR, _AM, _UCDs, _CM],
    [[() => ClientIdType, 0], 0, [() => SessionType, 0], [() => ChallengeResponsesType, 0], () => AnalyticsMetadataType$, [() => UserContextDataType$, 0], 128 | 0], 2
];
var RespondToAuthChallengeResponse$ = [3, n0, _RTACRe,
    0,
    [_CN, _S, _CP, _AR],
    [0, [() => SessionType, 0], 128 | 0, [() => AuthenticationResultType$, 0]]
];
var RevokeTokenRequest$ = [3, n0, _RTRe,
    0,
    [_To, _CI, _CS],
    [[() => TokenModelType, 0], [() => ClientIdType, 0], [() => ClientSecretType, 0]], 2
];
var RevokeTokenResponse$ = [3, n0, _RTRev,
    0,
    [],
    []
];
var RiskConfigurationType$ = [3, n0, _RCT,
    0,
    [_UPI, _CI, _CCRC, _ATRC, _REC, _LMD],
    [0, [() => ClientIdType, 0], () => CompromisedCredentialsRiskConfigurationType$, () => AccountTakeoverRiskConfigurationType$, () => RiskExceptionConfigurationType$, 4]
];
var RiskExceptionConfigurationType$ = [3, n0, _RECT,
    0,
    [_BIPRL, _SIPRL],
    [64 | 0, 64 | 0]
];
var RoutingType$ = [3, n0, _RTo,
    0,
    [_Fa],
    [() => FailoverType$]
];
var S3ConfigurationType$ = [3, n0, _SCTo,
    0,
    [_BA],
    [0]
];
var SchemaAttributeType$ = [3, n0, _SAT,
    0,
    [_Na, _ADT, _DOA, _Mu, _Req, _NAC, _SAC],
    [0, 0, 2, 2, 2, () => NumberAttributeConstraintsType$, () => StringAttributeConstraintsType$]
];
var SetLogDeliveryConfigurationRequest$ = [3, n0, _SLDCR,
    0,
    [_UPI, _LCo],
    [0, () => LogConfigurationListType], 2
];
var SetLogDeliveryConfigurationResponse$ = [3, n0, _SLDCRe,
    0,
    [_LDC],
    [() => LogDeliveryConfigurationType$]
];
var SetRiskConfigurationRequest$ = [3, n0, _SRCR,
    0,
    [_UPI, _CI, _CCRC, _ATRC, _REC],
    [0, [() => ClientIdType, 0], () => CompromisedCredentialsRiskConfigurationType$, () => AccountTakeoverRiskConfigurationType$, () => RiskExceptionConfigurationType$], 1
];
var SetRiskConfigurationResponse$ = [3, n0, _SRCRe,
    0,
    [_RC],
    [[() => RiskConfigurationType$, 0]], 1
];
var SetUICustomizationRequest$ = [3, n0, _SUICR,
    0,
    [_UPI, _CI, _CSS, _IFm],
    [0, [() => ClientIdType, 0], 0, 21], 1
];
var SetUICustomizationResponse$ = [3, n0, _SUICRe,
    0,
    [_UIC],
    [[() => UICustomizationType$, 0]], 1
];
var SetUserMFAPreferenceRequest$ = [3, n0, _SUMFAPR,
    0,
    [_ATc, _SMSMS, _STMS, _EMS, _WAMS],
    [[() => TokenModelType, 0], () => SMSMfaSettingsType$, () => SoftwareTokenMfaSettingsType$, () => EmailMfaSettingsType$, () => WebAuthnMfaSettingsType$], 1
];
var SetUserMFAPreferenceResponse$ = [3, n0, _SUMFAPRe,
    0,
    [],
    []
];
var SetUserPoolMfaConfigRequest$ = [3, n0, _SUPMCR,
    0,
    [_UPI, _SMC, _STMC, _EMC, _MC, _WAC],
    [0, () => SmsMfaConfigType$, () => SoftwareTokenMfaConfigType$, () => EmailMfaConfigType$, 0, () => WebAuthnConfigurationType$], 1
];
var SetUserPoolMfaConfigResponse$ = [3, n0, _SUPMCRe,
    0,
    [_SMC, _STMC, _EMC, _MC, _WAC],
    [() => SmsMfaConfigType$, () => SoftwareTokenMfaConfigType$, () => EmailMfaConfigType$, 0, () => WebAuthnConfigurationType$]
];
var SetUserSettingsRequest$ = [3, n0, _SUSR,
    0,
    [_ATc, _MFAO],
    [[() => TokenModelType, 0], () => MFAOptionListType], 2
];
var SetUserSettingsResponse$ = [3, n0, _SUSRe,
    0,
    [],
    []
];
var SignInPolicyType$ = [3, n0, _SIPT,
    0,
    [_AFAF],
    [64 | 0]
];
var SignUpRequest$ = [3, n0, _SUR,
    0,
    [_CI, _U, _SH, _P, _UA, _VD, _AM, _UCDs, _CM],
    [[() => ClientIdType, 0], [() => UsernameType, 0], [() => SecretHashType, 0], [() => PasswordType, 0], [() => AttributeListType, 0], [() => AttributeListType, 0], () => AnalyticsMetadataType$, [() => UserContextDataType$, 0], 128 | 0], 2
];
var SignUpResponse$ = [3, n0, _SURi,
    0,
    [_UCs, _USs, _CDD, _S],
    [2, 0, () => CodeDeliveryDetailsType$, [() => SessionType, 0]], 2
];
var SmsConfigurationType$ = [3, n0, _SCTm,
    0,
    [_SCA, _EIx, _SRn, _ESu],
    [0, 0, 0, () => EumsSmsConfigurationType$]
];
var SmsMfaConfigType$ = [3, n0, _SMCT,
    0,
    [_SAM, _SCm],
    [0, () => SmsConfigurationType$]
];
var SMSMfaSettingsType$ = [3, n0, _SMSMST,
    0,
    [_E, _PM],
    [2, 2]
];
var SoftwareTokenMfaConfigType$ = [3, n0, _STMCT,
    0,
    [_E],
    [2]
];
var SoftwareTokenMfaSettingsType$ = [3, n0, _STMST,
    0,
    [_E, _PM],
    [2, 2]
];
var StartUserImportJobRequest$ = [3, n0, _SUIJR,
    0,
    [_UPI, _JI],
    [0, 0], 2
];
var StartUserImportJobResponse$ = [3, n0, _SUIJRt,
    0,
    [_UIJ],
    [() => UserImportJobType$]
];
var StartWebAuthnRegistrationRequest$ = [3, n0, _SWARR,
    0,
    [_ATc],
    [[() => TokenModelType, 0]], 1
];
var StartWebAuthnRegistrationResponse$ = [3, n0, _SWARRt,
    0,
    [_CCO],
    [15], 1
];
var StopUserImportJobRequest$ = [3, n0, _SUIJRto,
    0,
    [_UPI, _JI],
    [0, 0], 2
];
var StopUserImportJobResponse$ = [3, n0, _SUIJRtop,
    0,
    [_UIJ],
    [() => UserImportJobType$]
];
var StringAttributeConstraintsType$ = [3, n0, _SACT,
    0,
    [_MLi, _MLa],
    [0, 0]
];
var TagResourceRequest$ = [3, n0, _TRR,
    0,
    [_RAes, _Ta],
    [0, 128 | 0], 2
];
var TagResourceResponse$ = [3, n0, _TRRa,
    0,
    [],
    []
];
var TermsDescriptionType$ = [3, n0, _TDT,
    0,
    [_TI, _TN, _En, _CDr, _LMD],
    [0, 0, 0, 4, 4], 5
];
var TermsType$ = [3, n0, _TTe,
    0,
    [_TI, _UPI, _CI, _TN, _TS, _En, _Li, _CDr, _LMD],
    [0, 0, [() => ClientIdType, 0], 0, 0, 0, 128 | 0, 4, 4], 9
];
var TokenValidityUnitsType$ = [3, n0, _TVUT,
    0,
    [_ATc, _IT, _RT],
    [0, 0, 0]
];
var UICustomizationType$ = [3, n0, _UICT,
    0,
    [_UPI, _CI, _IU, _CSS, _CSSV, _LMD, _CDr],
    [0, [() => ClientIdType, 0], 0, 0, 0, 4, 4]
];
var UntagResourceRequest$ = [3, n0, _URR,
    0,
    [_RAes, _TK],
    [0, 64 | 0], 2
];
var UntagResourceResponse$ = [3, n0, _URRn,
    0,
    [],
    []
];
var UpdateAuthEventFeedbackRequest$ = [3, n0, _UAEFR,
    0,
    [_UPI, _U, _EI, _FTe, _FV],
    [0, [() => UsernameType, 0], 0, [() => TokenModelType, 0], 0], 5
];
var UpdateAuthEventFeedbackResponse$ = [3, n0, _UAEFRp,
    0,
    [],
    []
];
var UpdateDeviceStatusRequest$ = [3, n0, _UDSR,
    0,
    [_ATc, _DK, _DRS],
    [[() => TokenModelType, 0], 0, 0], 2
];
var UpdateDeviceStatusResponse$ = [3, n0, _UDSRp,
    0,
    [],
    []
];
var UpdateGroupRequest$ = [3, n0, _UGR,
    0,
    [_GN, _UPI, _Desc, _RA, _Pr],
    [0, 0, 0, 0, 1], 2
];
var UpdateGroupResponse$ = [3, n0, _UGRp,
    0,
    [_Gr],
    [() => GroupType$]
];
var UpdateIdentityProviderRequest$ = [3, n0, _UIPR,
    0,
    [_UPI, _PN, _PD, _AMt, _II],
    [0, 0, 128 | 0, 128 | 0, 64 | 0], 2
];
var UpdateIdentityProviderResponse$ = [3, n0, _UIPRp,
    0,
    [_IP],
    [() => IdentityProviderType$], 1
];
var UpdateManagedLoginBrandingRequest$ = [3, n0, _UMLBR,
    0,
    [_UPI, _MLBI, _UCPV, _Se, _As],
    [0, 0, 2, 15, () => AssetListType]
];
var UpdateManagedLoginBrandingResponse$ = [3, n0, _UMLBRp,
    0,
    [_MLB],
    [() => ManagedLoginBrandingType$]
];
var UpdateProvisionedLimitRequest$ = [3, n0, _UPLR,
    0,
    [_LD, _RLV],
    [() => LimitDefinitionType$, 1], 2
];
var UpdateProvisionedLimitResponse$ = [3, n0, _UPLRp,
    0,
    [_L],
    [() => LimitType$], 1
];
var UpdateResourceServerRequest$ = [3, n0, _URSR,
    0,
    [_UPI, _I, _Na, _Sc],
    [0, 0, 0, () => ResourceServerScopeListType], 3
];
var UpdateResourceServerResponse$ = [3, n0, _URSRp,
    0,
    [_RS],
    [() => ResourceServerType$], 1
];
var UpdateTermsRequest$ = [3, n0, _UTR,
    0,
    [_TI, _UPI, _TN, _TS, _En, _Li],
    [0, 0, 0, 0, 0, 128 | 0], 2
];
var UpdateTermsResponse$ = [3, n0, _UTRp,
    0,
    [_T],
    [[() => TermsType$, 0]]
];
var UpdateUserAttributesRequest$ = [3, n0, _UUAR,
    0,
    [_UA, _ATc, _CM],
    [[() => AttributeListType, 0], [() => TokenModelType, 0], 128 | 0], 2
];
var UpdateUserAttributesResponse$ = [3, n0, _UUARp,
    0,
    [_CDDL],
    [() => CodeDeliveryDetailsListType]
];
var UpdateUserPoolClientRequest$ = [3, n0, _UUPCR,
    0,
    [_UPI, _CI, _CNl, _RTV, _ATV, _ITV, _TVU, _RAe, _WA, _EAF, _SIP, _CURL, _LURL, _DRURI, _AOAF, _AOAS, _AOAFUPC, _ACn, _PUEE, _ETR, _EPAUCD, _ASV, _RTR],
    [0, [() => ClientIdType, 0], 0, 1, 1, 1, () => TokenValidityUnitsType$, 64 | 0, 64 | 0, 64 | 0, 64 | 0, 64 | 0, 64 | 0, 0, 64 | 0, 64 | 0, 2, () => AnalyticsConfigurationType$, 0, 2, 2, 1, () => RefreshTokenRotationType$], 2
];
var UpdateUserPoolClientResponse$ = [3, n0, _UUPCRp,
    0,
    [_UPC],
    [[() => UserPoolClientType$, 0]]
];
var UpdateUserPoolDomainRequest$ = [3, n0, _UUPDR,
    0,
    [_Do, _UPI, _MLV, _CDC, _R],
    [0, 0, 1, () => CustomDomainConfigType$, () => RoutingType$], 2
];
var UpdateUserPoolDomainResponse$ = [3, n0, _UUPDRp,
    0,
    [_MLV, _CFD, _R],
    [1, 0, () => RoutingType$]
];
var UpdateUserPoolReplicaRequest$ = [3, n0, _UUPRR,
    0,
    [_UPI, _RN, _St],
    [0, 0, 0], 3
];
var UpdateUserPoolReplicaResponse$ = [3, n0, _UUPRRp,
    0,
    [_UPR],
    [() => UserPoolReplicaType$]
];
var UpdateUserPoolRequest$ = [3, n0, _UUPR,
    0,
    [_UPI, _Po, _DP, _LC, _AVA, _SVM, _EVM, _EVS, _VMT, _SAM, _UAUS, _MC, _DC, _EC, _SCm, _UPT, _ACUC, _UPAO, _ARS, _PNo, _UPTs, _KC, _IC],
    [0, () => UserPoolPolicyType$, 0, () => LambdaConfigType$, 64 | 0, 0, 0, 0, () => VerificationMessageTemplateType$, 0, () => UserAttributeUpdateSettingsType$, 0, () => DeviceConfigurationType$, () => EmailConfigurationType$, () => SmsConfigurationType$, 128 | 0, () => AdminCreateUserConfigType$, () => UserPoolAddOnsType$, () => AccountRecoverySettingType$, 0, 0, () => KeyConfigurationType$, () => IssuerConfigurationType$], 1
];
var UpdateUserPoolResponse$ = [3, n0, _UUPRp,
    0,
    [],
    []
];
var UserAttributeUpdateSettingsType$ = [3, n0, _UAUST,
    0,
    [_ARVBU],
    [64 | 0]
];
var UserContextDataType$ = [3, n0, _UCDT,
    8,
    [_IA, _ED],
    [0, 0]
];
var UserImportJobType$ = [3, n0, _UIJT,
    0,
    [_JN, _JI, _UPI, _PSUr, _CDr, _SDt, _CDo, _St, _CWLRA, _IUm, _SUk, _FU, _CMom, _PHA],
    [0, 0, 0, 0, 4, 4, 4, 0, 0, 1, 1, 1, 0, 0]
];
var UsernameConfigurationType$ = [3, n0, _UCT,
    0,
    [_CSa],
    [2], 1
];
var UserPoolAddOnsType$ = [3, n0, _UPAOT,
    0,
    [_ASM, _ASAF],
    [0, () => AdvancedSecurityAdditionalFlowsType$], 1
];
var UserPoolClientDescription$ = [3, n0, _UPCD,
    0,
    [_CI, _UPI, _CNl],
    [[() => ClientIdType, 0], 0, 0]
];
var UserPoolClientType$ = [3, n0, _UPCT,
    0,
    [_UPI, _CNl, _CI, _CS, _LMD, _CDr, _RTV, _ATV, _ITV, _TVU, _RAe, _WA, _EAF, _SIP, _CURL, _LURL, _DRURI, _AOAF, _AOAS, _AOAFUPC, _ACn, _PUEE, _ETR, _EPAUCD, _ASV, _RTR],
    [0, 0, [() => ClientIdType, 0], [() => ClientSecretType, 0], 4, 4, 1, 1, 1, () => TokenValidityUnitsType$, 64 | 0, 64 | 0, 64 | 0, 64 | 0, 64 | 0, 64 | 0, 0, 64 | 0, 64 | 0, 2, () => AnalyticsConfigurationType$, 0, 2, 2, 1, () => RefreshTokenRotationType$]
];
var UserPoolDescriptionType$ = [3, n0, _UPDT,
    0,
    [_Id, _Na, _LC, _St, _LMD, _CDr, _RR],
    [0, 0, () => LambdaConfigType$, 0, 4, 4, 64 | 0]
];
var UserPoolPolicyType$ = [3, n0, _UPPT,
    0,
    [_PPa, _SIPi],
    [() => PasswordPolicyType$, () => SignInPolicyType$]
];
var UserPoolReplicaType$ = [3, n0, _UPRT,
    0,
    [_RN, _St, _Ro, _UPA],
    [0, 0, 0, 0]
];
var UserPoolType$ = [3, n0, _UPTse,
    0,
    [_Id, _Na, _Po, _DP, _LC, _St, _LMD, _CDr, _SAc, _AVA, _AAl, _UAs, _SVM, _EVM, _EVS, _VMT, _SAM, _UAUS, _MC, _DC, _ENOU, _EC, _SCm, _UPT, _SCF, _ECF, _Do, _CDu, _ACUC, _UPAO, _UC, _Ar, _ARS, _UPTs, _KC, _IC],
    [0, 0, () => UserPoolPolicyType$, 0, () => LambdaConfigType$, 0, 4, 4, () => SchemaAttributesListType, 64 | 0, 64 | 0, 64 | 0, 0, 0, 0, () => VerificationMessageTemplateType$, 0, () => UserAttributeUpdateSettingsType$, 0, () => DeviceConfigurationType$, 1, () => EmailConfigurationType$, () => SmsConfigurationType$, 128 | 0, 0, 0, 0, 0, () => AdminCreateUserConfigType$, () => UserPoolAddOnsType$, () => UsernameConfigurationType$, 0, () => AccountRecoverySettingType$, 0, () => KeyConfigurationType$, () => IssuerConfigurationType$]
];
var UserType$ = [3, n0, _UTs,
    0,
    [_U, _At, _UCD, _ULMD, _E, _US, _MFAO],
    [[() => UsernameType, 0], [() => AttributeListType, 0], 4, 4, 2, 0, () => MFAOptionListType]
];
var VerificationMessageTemplateType$ = [3, n0, _VMTT,
    0,
    [_SM, _EM, _ESm, _EMBL, _ESBL, _DEO],
    [0, 0, 0, 0, 0, 0]
];
var VerifySoftwareTokenRequest$ = [3, n0, _VSTR,
    0,
    [_UCse, _ATc, _S, _FDN],
    [[() => SoftwareTokenMFAUserCodeType, 0], [() => TokenModelType, 0], [() => SessionType, 0], 0], 1
];
var VerifySoftwareTokenResponse$ = [3, n0, _VSTRe,
    0,
    [_St, _S],
    [0, [() => SessionType, 0]]
];
var VerifyUserAttributeRequest$ = [3, n0, _VUAR,
    0,
    [_ATc, _AN, _Cod],
    [[() => TokenModelType, 0], 0, 0], 3
];
var VerifyUserAttributeResponse$ = [3, n0, _VUARe,
    0,
    [],
    []
];
var WebAuthnConfigurationType$ = [3, n0, _WACT,
    0,
    [_RPI, _UV, _FCa],
    [0, 0, 0]
];
var WebAuthnCredentialDescription$ = [3, n0, _WACD,
    0,
    [_CIr, _FCN, _RPI, _ATu, _CAr, _AAu],
    [0, 0, 0, 64 | 0, 4, 0], 5
];
var WebAuthnMfaSettingsType$ = [3, n0, _WAMST,
    0,
    [_E],
    [2]
];
var __Unit = "unit";
var AssetListType = [1, n0, _ALT,
    0, () => AssetType$
];
var AttributeListType = [1, n0, _ALTt,
    0, [() => AttributeType$,
        0]
];
var AuthEventsType = [1, n0, _AETu,
    0, () => AuthEventType$
];
var ChallengeResponseListType = [1, n0, _CRLT,
    0, () => ChallengeResponseType$
];
var ClientSecretDescriptorListType = [1, n0, _CSDLT,
    0, [() => ClientSecretDescriptorType$,
        0]
];
var CodeDeliveryDetailsListType = [1, n0, _CDDLT,
    0, () => CodeDeliveryDetailsType$
];
var CustomAttributesListType = [1, n0, _CALT,
    0, () => SchemaAttributeType$
];
var DeviceListType = [1, n0, _DLT,
    0, [() => DeviceType$,
        0]
];
var GroupListType = [1, n0, _GLT,
    0, () => GroupType$
];
var HttpHeaderList = [1, n0, _HHL,
    0, () => HttpHeader$
];
var LogConfigurationListType = [1, n0, _LCLT,
    0, () => LogConfigurationType$
];
var MFAOptionListType = [1, n0, _MFAOLT,
    0, () => MFAOptionType$
];
var ProvidersListType = [1, n0, _PLT,
    0, () => ProviderDescription$
];
var RecoveryMechanismsType = [1, n0, _RMT,
    0, () => RecoveryOptionType$
];
var ResourceServerScopeListType = [1, n0, _RSSLT,
    0, () => ResourceServerScopeType$
];
var ResourceServersListType = [1, n0, _RSLT,
    0, () => ResourceServerType$
];
var SchemaAttributesListType = [1, n0, _SALT,
    0, () => SchemaAttributeType$
];
var TermsDescriptionListType = [1, n0, _TDLT,
    0, () => TermsDescriptionType$
];
var UserImportJobsListType = [1, n0, _UIJLT,
    0, () => UserImportJobType$
];
var UserPoolClientListType = [1, n0, _UPCLT,
    0, [() => UserPoolClientDescription$,
        0]
];
var UserPoolListType = [1, n0, _UPLT,
    0, () => UserPoolDescriptionType$
];
var UserPoolReplicaListType = [1, n0, _UPRLT,
    0, () => UserPoolReplicaType$
];
var UsersListType = [1, n0, _ULT,
    0, [() => UserType$,
        0]
];
var WebAuthnCredentialDescriptionListType = [1, n0, _WACDLT,
    0, () => WebAuthnCredentialDescription$
];
var AuthParametersType = [2, n0, _APT,
    8, 0, 0
];
var ChallengeResponsesType = [2, n0, _CRTh,
    8, 0, 0
];
var AddCustomAttributes$ = [9, n0, _ACA,
    0, () => AddCustomAttributesRequest$, () => AddCustomAttributesResponse$
];
var AddUserPoolClientSecret$ = [9, n0, _AUPCS,
    0, () => AddUserPoolClientSecretRequest$, () => AddUserPoolClientSecretResponse$
];
var AdminAddUserToGroup$ = [9, n0, _AAUTG,
    0, () => AdminAddUserToGroupRequest$, () => __Unit
];
var AdminConfirmSignUp$ = [9, n0, _ACSU,
    0, () => AdminConfirmSignUpRequest$, () => AdminConfirmSignUpResponse$
];
var AdminCreateUser$ = [9, n0, _ACU,
    0, () => AdminCreateUserRequest$, () => AdminCreateUserResponse$
];
var AdminDeleteSoftwareToken$ = [9, n0, _ADST,
    0, () => AdminDeleteSoftwareTokenRequest$, () => AdminDeleteSoftwareTokenResponse$
];
var AdminDeleteUser$ = [9, n0, _ADU,
    0, () => AdminDeleteUserRequest$, () => __Unit
];
var AdminDeleteUserAttributes$ = [9, n0, _ADUA,
    0, () => AdminDeleteUserAttributesRequest$, () => AdminDeleteUserAttributesResponse$
];
var AdminDisableProviderForUser$ = [9, n0, _ADPFU,
    0, () => AdminDisableProviderForUserRequest$, () => AdminDisableProviderForUserResponse$
];
var AdminDisableUser$ = [9, n0, _ADUd,
    0, () => AdminDisableUserRequest$, () => AdminDisableUserResponse$
];
var AdminEnableUser$ = [9, n0, _AEU,
    0, () => AdminEnableUserRequest$, () => AdminEnableUserResponse$
];
var AdminForgetDevice$ = [9, n0, _AFD,
    0, () => AdminForgetDeviceRequest$, () => __Unit
];
var AdminGetDevice$ = [9, n0, _AGD,
    0, () => AdminGetDeviceRequest$, () => AdminGetDeviceResponse$
];
var AdminGetUser$ = [9, n0, _AGU,
    0, () => AdminGetUserRequest$, () => AdminGetUserResponse$
];
var AdminGetUserAuthFactors$ = [9, n0, _AGUAF,
    0, () => AdminGetUserAuthFactorsRequest$, () => AdminGetUserAuthFactorsResponse$
];
var AdminInitiateAuth$ = [9, n0, _AIA,
    0, () => AdminInitiateAuthRequest$, () => AdminInitiateAuthResponse$
];
var AdminLinkProviderForUser$ = [9, n0, _ALPFU,
    0, () => AdminLinkProviderForUserRequest$, () => AdminLinkProviderForUserResponse$
];
var AdminListDevices$ = [9, n0, _ALD,
    0, () => AdminListDevicesRequest$, () => AdminListDevicesResponse$
];
var AdminListGroupsForUser$ = [9, n0, _ALGFU,
    0, () => AdminListGroupsForUserRequest$, () => AdminListGroupsForUserResponse$
];
var AdminListUserAuthEvents$ = [9, n0, _ALUAE,
    0, () => AdminListUserAuthEventsRequest$, () => AdminListUserAuthEventsResponse$
];
var AdminRemoveUserFromGroup$ = [9, n0, _ARUFG,
    0, () => AdminRemoveUserFromGroupRequest$, () => __Unit
];
var AdminResetUserPassword$ = [9, n0, _ARUP,
    0, () => AdminResetUserPasswordRequest$, () => AdminResetUserPasswordResponse$
];
var AdminRespondToAuthChallenge$ = [9, n0, _ARTAC,
    0, () => AdminRespondToAuthChallengeRequest$, () => AdminRespondToAuthChallengeResponse$
];
var AdminSetUserMFAPreference$ = [9, n0, _ASUMFAP,
    0, () => AdminSetUserMFAPreferenceRequest$, () => AdminSetUserMFAPreferenceResponse$
];
var AdminSetUserPassword$ = [9, n0, _ASUP,
    0, () => AdminSetUserPasswordRequest$, () => AdminSetUserPasswordResponse$
];
var AdminSetUserSettings$ = [9, n0, _ASUS,
    0, () => AdminSetUserSettingsRequest$, () => AdminSetUserSettingsResponse$
];
var AdminUpdateAuthEventFeedback$ = [9, n0, _AUAEF,
    0, () => AdminUpdateAuthEventFeedbackRequest$, () => AdminUpdateAuthEventFeedbackResponse$
];
var AdminUpdateDeviceStatus$ = [9, n0, _AUDS,
    0, () => AdminUpdateDeviceStatusRequest$, () => AdminUpdateDeviceStatusResponse$
];
var AdminUpdateUserAttributes$ = [9, n0, _AUUA,
    0, () => AdminUpdateUserAttributesRequest$, () => AdminUpdateUserAttributesResponse$
];
var AdminUserGlobalSignOut$ = [9, n0, _AUGSO,
    0, () => AdminUserGlobalSignOutRequest$, () => AdminUserGlobalSignOutResponse$
];
var AssociateSoftwareToken$ = [9, n0, _AST,
    0, () => AssociateSoftwareTokenRequest$, () => AssociateSoftwareTokenResponse$
];
var ChangePassword$ = [9, n0, _CPh,
    0, () => ChangePasswordRequest$, () => ChangePasswordResponse$
];
var CompleteWebAuthnRegistration$ = [9, n0, _CWAR,
    0, () => CompleteWebAuthnRegistrationRequest$, () => CompleteWebAuthnRegistrationResponse$
];
var ConfirmDevice$ = [9, n0, _CDon,
    0, () => ConfirmDeviceRequest$, () => ConfirmDeviceResponse$
];
var ConfirmForgotPassword$ = [9, n0, _CFP,
    0, () => ConfirmForgotPasswordRequest$, () => ConfirmForgotPasswordResponse$
];
var ConfirmSignUp$ = [9, n0, _CSU,
    0, () => ConfirmSignUpRequest$, () => ConfirmSignUpResponse$
];
var CreateGroup$ = [9, n0, _CG,
    0, () => CreateGroupRequest$, () => CreateGroupResponse$
];
var CreateIdentityProvider$ = [9, n0, _CIP,
    0, () => CreateIdentityProviderRequest$, () => CreateIdentityProviderResponse$
];
var CreateManagedLoginBranding$ = [9, n0, _CMLB,
    0, () => CreateManagedLoginBrandingRequest$, () => CreateManagedLoginBrandingResponse$
];
var CreateResourceServer$ = [9, n0, _CRS,
    0, () => CreateResourceServerRequest$, () => CreateResourceServerResponse$
];
var CreateTerms$ = [9, n0, _CT,
    0, () => CreateTermsRequest$, () => CreateTermsResponse$
];
var CreateUserImportJob$ = [9, n0, _CUIJ,
    0, () => CreateUserImportJobRequest$, () => CreateUserImportJobResponse$
];
var CreateUserPool$ = [9, n0, _CUP,
    0, () => CreateUserPoolRequest$, () => CreateUserPoolResponse$
];
var CreateUserPoolClient$ = [9, n0, _CUPC,
    0, () => CreateUserPoolClientRequest$, () => CreateUserPoolClientResponse$
];
var CreateUserPoolDomain$ = [9, n0, _CUPD,
    0, () => CreateUserPoolDomainRequest$, () => CreateUserPoolDomainResponse$
];
var CreateUserPoolReplica$ = [9, n0, _CUPRre,
    0, () => CreateUserPoolReplicaRequest$, () => CreateUserPoolReplicaResponse$
];
var DeleteGroup$ = [9, n0, _DG,
    0, () => DeleteGroupRequest$, () => __Unit
];
var DeleteIdentityProvider$ = [9, n0, _DIP,
    0, () => DeleteIdentityProviderRequest$, () => __Unit
];
var DeleteManagedLoginBranding$ = [9, n0, _DMLB,
    0, () => DeleteManagedLoginBrandingRequest$, () => __Unit
];
var DeleteResourceServer$ = [9, n0, _DRSe,
    0, () => DeleteResourceServerRequest$, () => __Unit
];
var DeleteTerms$ = [9, n0, _DTe,
    0, () => DeleteTermsRequest$, () => __Unit
];
var DeleteUser$ = [9, n0, _DUe,
    0, () => DeleteUserRequest$, () => __Unit
];
var DeleteUserAttributes$ = [9, n0, _DUA,
    0, () => DeleteUserAttributesRequest$, () => DeleteUserAttributesResponse$
];
var DeleteUserPool$ = [9, n0, _DUP,
    0, () => DeleteUserPoolRequest$, () => __Unit
];
var DeleteUserPoolClient$ = [9, n0, _DUPC,
    0, () => DeleteUserPoolClientRequest$, () => __Unit
];
var DeleteUserPoolClientSecret$ = [9, n0, _DUPCS,
    0, () => DeleteUserPoolClientSecretRequest$, () => DeleteUserPoolClientSecretResponse$
];
var DeleteUserPoolDomain$ = [9, n0, _DUPD,
    0, () => DeleteUserPoolDomainRequest$, () => DeleteUserPoolDomainResponse$
];
var DeleteUserPoolReplica$ = [9, n0, _DUPRel,
    0, () => DeleteUserPoolReplicaRequest$, () => DeleteUserPoolReplicaResponse$
];
var DeleteWebAuthnCredential$ = [9, n0, _DWAC,
    0, () => DeleteWebAuthnCredentialRequest$, () => DeleteWebAuthnCredentialResponse$
];
var DescribeIdentityProvider$ = [9, n0, _DIPe,
    0, () => DescribeIdentityProviderRequest$, () => DescribeIdentityProviderResponse$
];
var DescribeManagedLoginBranding$ = [9, n0, _DMLBe,
    0, () => DescribeManagedLoginBrandingRequest$, () => DescribeManagedLoginBrandingResponse$
];
var DescribeManagedLoginBrandingByClient$ = [9, n0, _DMLBBC,
    0, () => DescribeManagedLoginBrandingByClientRequest$, () => DescribeManagedLoginBrandingByClientResponse$
];
var DescribeResourceServer$ = [9, n0, _DRSes,
    0, () => DescribeResourceServerRequest$, () => DescribeResourceServerResponse$
];
var DescribeRiskConfiguration$ = [9, n0, _DRC,
    0, () => DescribeRiskConfigurationRequest$, () => DescribeRiskConfigurationResponse$
];
var DescribeTerms$ = [9, n0, _DTes,
    0, () => DescribeTermsRequest$, () => DescribeTermsResponse$
];
var DescribeTermsByClient$ = [9, n0, _DTBC,
    0, () => DescribeTermsByClientRequest$, () => DescribeTermsByClientResponse$
];
var DescribeUserImportJob$ = [9, n0, _DUIJ,
    0, () => DescribeUserImportJobRequest$, () => DescribeUserImportJobResponse$
];
var DescribeUserPool$ = [9, n0, _DUPe,
    0, () => DescribeUserPoolRequest$, () => DescribeUserPoolResponse$
];
var DescribeUserPoolClient$ = [9, n0, _DUPCe,
    0, () => DescribeUserPoolClientRequest$, () => DescribeUserPoolClientResponse$
];
var DescribeUserPoolDomain$ = [9, n0, _DUPDe,
    0, () => DescribeUserPoolDomainRequest$, () => DescribeUserPoolDomainResponse$
];
var ForgetDevice$ = [9, n0, _FDo,
    0, () => ForgetDeviceRequest$, () => __Unit
];
var ForgotPassword$ = [9, n0, _FP,
    0, () => ForgotPasswordRequest$, () => ForgotPasswordResponse$
];
var GetClientToken$ = [9, n0, _GCT,
    0, () => GetClientTokenRequest$, () => GetClientTokenResponse$
];
var GetCSVHeader$ = [9, n0, _GCSVH,
    0, () => GetCSVHeaderRequest$, () => GetCSVHeaderResponse$
];
var GetDevice$ = [9, n0, _GD,
    0, () => GetDeviceRequest$, () => GetDeviceResponse$
];
var GetGroup$ = [9, n0, _GG,
    0, () => GetGroupRequest$, () => GetGroupResponse$
];
var GetIdentityProviderByIdentifier$ = [9, n0, _GIPBI,
    0, () => GetIdentityProviderByIdentifierRequest$, () => GetIdentityProviderByIdentifierResponse$
];
var GetLogDeliveryConfiguration$ = [9, n0, _GLDC,
    0, () => GetLogDeliveryConfigurationRequest$, () => GetLogDeliveryConfigurationResponse$
];
var GetProvisionedLimit$ = [9, n0, _GPL,
    0, () => GetProvisionedLimitRequest$, () => GetProvisionedLimitResponse$
];
var GetSigningCertificate$ = [9, n0, _GSC,
    0, () => GetSigningCertificateRequest$, () => GetSigningCertificateResponse$
];
var GetTokensFromRefreshToken$ = [9, n0, _GTFRT,
    0, () => GetTokensFromRefreshTokenRequest$, () => GetTokensFromRefreshTokenResponse$
];
var GetUICustomization$ = [9, n0, _GUIC,
    0, () => GetUICustomizationRequest$, () => GetUICustomizationResponse$
];
var GetUser$ = [9, n0, _GU,
    0, () => GetUserRequest$, () => GetUserResponse$
];
var GetUserAttributeVerificationCode$ = [9, n0, _GUAVC,
    0, () => GetUserAttributeVerificationCodeRequest$, () => GetUserAttributeVerificationCodeResponse$
];
var GetUserAuthFactors$ = [9, n0, _GUAF,
    0, () => GetUserAuthFactorsRequest$, () => GetUserAuthFactorsResponse$
];
var GetUserPoolMfaConfig$ = [9, n0, _GUPMC,
    0, () => GetUserPoolMfaConfigRequest$, () => GetUserPoolMfaConfigResponse$
];
var GlobalSignOut$ = [9, n0, _GSO,
    0, () => GlobalSignOutRequest$, () => GlobalSignOutResponse$
];
var InitiateAuth$ = [9, n0, _IAn,
    0, () => InitiateAuthRequest$, () => InitiateAuthResponse$
];
var ListDevices$ = [9, n0, _LDi,
    0, () => ListDevicesRequest$, () => ListDevicesResponse$
];
var ListGroups$ = [9, n0, _LG,
    0, () => ListGroupsRequest$, () => ListGroupsResponse$
];
var ListIdentityProviders$ = [9, n0, _LIP,
    0, () => ListIdentityProvidersRequest$, () => ListIdentityProvidersResponse$
];
var ListResourceServers$ = [9, n0, _LRS,
    0, () => ListResourceServersRequest$, () => ListResourceServersResponse$
];
var ListTagsForResource$ = [9, n0, _LTFR,
    0, () => ListTagsForResourceRequest$, () => ListTagsForResourceResponse$
];
var ListTerms$ = [9, n0, _LTi,
    0, () => ListTermsRequest$, () => ListTermsResponse$
];
var ListUserImportJobs$ = [9, n0, _LUIJ,
    0, () => ListUserImportJobsRequest$, () => ListUserImportJobsResponse$
];
var ListUserPoolClients$ = [9, n0, _LUPC,
    0, () => ListUserPoolClientsRequest$, () => ListUserPoolClientsResponse$
];
var ListUserPoolClientSecrets$ = [9, n0, _LUPCS,
    0, () => ListUserPoolClientSecretsRequest$, () => ListUserPoolClientSecretsResponse$
];
var ListUserPoolReplicas$ = [9, n0, _LUPRis,
    0, () => ListUserPoolReplicasRequest$, () => ListUserPoolReplicasResponse$
];
var ListUserPools$ = [9, n0, _LUP,
    0, () => ListUserPoolsRequest$, () => ListUserPoolsResponse$
];
var ListUsers$ = [9, n0, _LU,
    0, () => ListUsersRequest$, () => ListUsersResponse$
];
var ListUsersInGroup$ = [9, n0, _LUIG,
    0, () => ListUsersInGroupRequest$, () => ListUsersInGroupResponse$
];
var ListWebAuthnCredentials$ = [9, n0, _LWAC,
    0, () => ListWebAuthnCredentialsRequest$, () => ListWebAuthnCredentialsResponse$
];
var ResendConfirmationCode$ = [9, n0, _RCC,
    0, () => ResendConfirmationCodeRequest$, () => ResendConfirmationCodeResponse$
];
var RespondToAuthChallenge$ = [9, n0, _RTAC,
    0, () => RespondToAuthChallengeRequest$, () => RespondToAuthChallengeResponse$
];
var RevokeToken$ = [9, n0, _RTev,
    0, () => RevokeTokenRequest$, () => RevokeTokenResponse$
];
var SetLogDeliveryConfiguration$ = [9, n0, _SLDC,
    0, () => SetLogDeliveryConfigurationRequest$, () => SetLogDeliveryConfigurationResponse$
];
var SetRiskConfiguration$ = [9, n0, _SRC,
    0, () => SetRiskConfigurationRequest$, () => SetRiskConfigurationResponse$
];
var SetUICustomization$ = [9, n0, _SUIC,
    0, () => SetUICustomizationRequest$, () => SetUICustomizationResponse$
];
var SetUserMFAPreference$ = [9, n0, _SUMFAP,
    0, () => SetUserMFAPreferenceRequest$, () => SetUserMFAPreferenceResponse$
];
var SetUserPoolMfaConfig$ = [9, n0, _SUPMC,
    0, () => SetUserPoolMfaConfigRequest$, () => SetUserPoolMfaConfigResponse$
];
var SetUserSettings$ = [9, n0, _SUS,
    0, () => SetUserSettingsRequest$, () => SetUserSettingsResponse$
];
var SignUp$ = [9, n0, _SUi,
    0, () => SignUpRequest$, () => SignUpResponse$
];
var StartUserImportJob$ = [9, n0, _SUIJ,
    0, () => StartUserImportJobRequest$, () => StartUserImportJobResponse$
];
var StartWebAuthnRegistration$ = [9, n0, _SWAR,
    0, () => StartWebAuthnRegistrationRequest$, () => StartWebAuthnRegistrationResponse$
];
var StopUserImportJob$ = [9, n0, _SUIJt,
    0, () => StopUserImportJobRequest$, () => StopUserImportJobResponse$
];
var TagResource$ = [9, n0, _TR,
    0, () => TagResourceRequest$, () => TagResourceResponse$
];
var UntagResource$ = [9, n0, _UR,
    0, () => UntagResourceRequest$, () => UntagResourceResponse$
];
var UpdateAuthEventFeedback$ = [9, n0, _UAEF,
    0, () => UpdateAuthEventFeedbackRequest$, () => UpdateAuthEventFeedbackResponse$
];
var UpdateDeviceStatus$ = [9, n0, _UDSp,
    0, () => UpdateDeviceStatusRequest$, () => UpdateDeviceStatusResponse$
];
var UpdateGroup$ = [9, n0, _UG,
    0, () => UpdateGroupRequest$, () => UpdateGroupResponse$
];
var UpdateIdentityProvider$ = [9, n0, _UIP,
    0, () => UpdateIdentityProviderRequest$, () => UpdateIdentityProviderResponse$
];
var UpdateManagedLoginBranding$ = [9, n0, _UMLB,
    0, () => UpdateManagedLoginBrandingRequest$, () => UpdateManagedLoginBrandingResponse$
];
var UpdateProvisionedLimit$ = [9, n0, _UPL,
    0, () => UpdateProvisionedLimitRequest$, () => UpdateProvisionedLimitResponse$
];
var UpdateResourceServer$ = [9, n0, _URS,
    0, () => UpdateResourceServerRequest$, () => UpdateResourceServerResponse$
];
var UpdateTerms$ = [9, n0, _UTp,
    0, () => UpdateTermsRequest$, () => UpdateTermsResponse$
];
var UpdateUserAttributes$ = [9, n0, _UUA,
    0, () => UpdateUserAttributesRequest$, () => UpdateUserAttributesResponse$
];
var UpdateUserPool$ = [9, n0, _UUP,
    0, () => UpdateUserPoolRequest$, () => UpdateUserPoolResponse$
];
var UpdateUserPoolClient$ = [9, n0, _UUPC,
    0, () => UpdateUserPoolClientRequest$, () => UpdateUserPoolClientResponse$
];
var UpdateUserPoolDomain$ = [9, n0, _UUPD,
    0, () => UpdateUserPoolDomainRequest$, () => UpdateUserPoolDomainResponse$
];
var UpdateUserPoolReplica$ = [9, n0, _UUPRpd,
    0, () => UpdateUserPoolReplicaRequest$, () => UpdateUserPoolReplicaResponse$
];
var VerifySoftwareToken$ = [9, n0, _VST,
    0, () => VerifySoftwareTokenRequest$, () => VerifySoftwareTokenResponse$
];
var VerifyUserAttribute$ = [9, n0, _VUA,
    0, () => VerifyUserAttributeRequest$, () => VerifyUserAttributeResponse$
];

const getRuntimeConfig$1 = (config) => {
    return {
        apiVersion: "2016-04-18",
        base64Decoder: config?.base64Decoder ?? fromBase64,
        base64Encoder: config?.base64Encoder ?? toBase64,
        disableHostPrefix: config?.disableHostPrefix ?? false,
        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
        extensions: config?.extensions ?? [],
        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultCognitoIdentityProviderHttpAuthSchemeProvider,
        httpAuthSchemes: config?.httpAuthSchemes ?? [
            {
                schemeId: "aws.auth#sigv4",
                identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
                signer: new AwsSdkSigV4Signer(),
            },
            {
                schemeId: "smithy.api#noAuth",
                identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
                signer: new NoAuthSigner(),
            },
        ],
        logger: config?.logger ?? new NoOpLogger(),
        protocol: config?.protocol ?? AwsJson1_1Protocol,
        protocolSettings: config?.protocolSettings ?? {
            defaultNamespace: "com.amazonaws.cognitoidentityprovider",
            errorTypeRegistries,
            xmlNamespace: "http://cognito-idp.amazonaws.com/doc/2016-04-18/",
            version: "2016-04-18",
            serviceTarget: "AWSCognitoIdentityProviderService",
        },
        serviceId: config?.serviceId ?? "Cognito Identity Provider",
        sha256: config?.sha256 ?? Sha256,
        urlParser: config?.urlParser ?? parseUrl,
        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
        utf8Encoder: config?.utf8Encoder ?? toUtf8,
    };
};

const getRuntimeConfig = (config) => {
    emitWarningIfUnsupportedVersion(process.version);
    const defaultsMode = resolveDefaultsModeConfig(config);
    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
    const clientSharedValues = getRuntimeConfig$1(config);
    emitWarningIfUnsupportedVersion$1(process.version);
    const loaderConfig = {
        profile: config?.profile,
        logger: clientSharedValues.logger,
    };
    return {
        ...clientSharedValues,
        ...config,
        runtime: "node",
        defaultsMode,
        authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
        credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
        region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
        requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
        retryMode: config?.retryMode ??
            loadConfig({
                ...NODE_RETRY_MODE_CONFIG_OPTIONS,
                default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE,
            }, config),
        streamCollector: config?.streamCollector ?? streamCollector,
        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig),
    };
};

const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
    let _credentials = runtimeConfig.credentials;
    return {
        setHttpAuthScheme(httpAuthScheme) {
            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
            if (index === -1) {
                _httpAuthSchemes.push(httpAuthScheme);
            }
            else {
                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
            }
        },
        httpAuthSchemes() {
            return _httpAuthSchemes;
        },
        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
            _httpAuthSchemeProvider = httpAuthSchemeProvider;
        },
        httpAuthSchemeProvider() {
            return _httpAuthSchemeProvider;
        },
        setCredentials(credentials) {
            _credentials = credentials;
        },
        credentials() {
            return _credentials;
        },
    };
};
const resolveHttpAuthRuntimeConfig = (config) => {
    return {
        httpAuthSchemes: config.httpAuthSchemes(),
        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
        credentials: config.credentials(),
    };
};

const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
    const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
    extensions.forEach((extension) => extension.configure(extensionConfiguration));
    return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};

class CognitoIdentityProviderClient extends Client {
    config;
    constructor(...[configuration]) {
        const _config_0 = getRuntimeConfig(configuration || {});
        super(_config_0);
        this.initConfig = _config_0;
        const _config_1 = resolveClientEndpointParameters(_config_0);
        const _config_2 = resolveUserAgentConfig(_config_1);
        const _config_3 = resolveRetryConfig(_config_2);
        const _config_4 = resolveRegionConfig(_config_3);
        const _config_5 = resolveHostHeaderConfig(_config_4);
        const _config_6 = resolveEndpointConfig(_config_5);
        const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
        this.config = _config_8;
        this.middlewareStack.use(getSchemaSerdePlugin(this.config));
        this.middlewareStack.use(getUserAgentPlugin(this.config));
        this.middlewareStack.use(getRetryPlugin(this.config));
        this.middlewareStack.use(getContentLengthPlugin(this.config));
        this.middlewareStack.use(getHostHeaderPlugin(this.config));
        this.middlewareStack.use(getLoggerPlugin(this.config));
        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
            httpAuthSchemeParametersProvider: defaultCognitoIdentityProviderHttpAuthSchemeParametersProvider,
            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
                "aws.auth#sigv4": config.credentials,
            }),
        }));
        this.middlewareStack.use(getHttpSigningPlugin(this.config));
    }
    destroy() {
        super.destroy();
    }
}

const command = makeBuilder(commonParams, "AWSCognitoIdentityProviderService", "CognitoIdentityProviderClient", getEndpointPlugin);
const _ep0 = {};
const _mw0 = (Command, cs, config, o) => [];

class AddCustomAttributesCommand extends command(_ep0, _mw0, "AddCustomAttributes", AddCustomAttributes$) {
}

class AddUserPoolClientSecretCommand extends command(_ep0, _mw0, "AddUserPoolClientSecret", AddUserPoolClientSecret$) {
}

class AdminAddUserToGroupCommand extends command(_ep0, _mw0, "AdminAddUserToGroup", AdminAddUserToGroup$) {
}

class AdminConfirmSignUpCommand extends command(_ep0, _mw0, "AdminConfirmSignUp", AdminConfirmSignUp$) {
}

class AdminCreateUserCommand extends command(_ep0, _mw0, "AdminCreateUser", AdminCreateUser$) {
}

class AdminDeleteSoftwareTokenCommand extends command(_ep0, _mw0, "AdminDeleteSoftwareToken", AdminDeleteSoftwareToken$) {
}

class AdminDeleteUserAttributesCommand extends command(_ep0, _mw0, "AdminDeleteUserAttributes", AdminDeleteUserAttributes$) {
}

class AdminDeleteUserCommand extends command(_ep0, _mw0, "AdminDeleteUser", AdminDeleteUser$) {
}

class AdminDisableProviderForUserCommand extends command(_ep0, _mw0, "AdminDisableProviderForUser", AdminDisableProviderForUser$) {
}

class AdminDisableUserCommand extends command(_ep0, _mw0, "AdminDisableUser", AdminDisableUser$) {
}

class AdminEnableUserCommand extends command(_ep0, _mw0, "AdminEnableUser", AdminEnableUser$) {
}

class AdminForgetDeviceCommand extends command(_ep0, _mw0, "AdminForgetDevice", AdminForgetDevice$) {
}

class AdminGetDeviceCommand extends command(_ep0, _mw0, "AdminGetDevice", AdminGetDevice$) {
}

class AdminGetUserAuthFactorsCommand extends command(_ep0, _mw0, "AdminGetUserAuthFactors", AdminGetUserAuthFactors$) {
}

class AdminGetUserCommand extends command(_ep0, _mw0, "AdminGetUser", AdminGetUser$) {
}

class AdminInitiateAuthCommand extends command(_ep0, _mw0, "AdminInitiateAuth", AdminInitiateAuth$) {
}

class AdminLinkProviderForUserCommand extends command(_ep0, _mw0, "AdminLinkProviderForUser", AdminLinkProviderForUser$) {
}

class AdminListDevicesCommand extends command(_ep0, _mw0, "AdminListDevices", AdminListDevices$) {
}

class AdminListGroupsForUserCommand extends command(_ep0, _mw0, "AdminListGroupsForUser", AdminListGroupsForUser$) {
}

class AdminListUserAuthEventsCommand extends command(_ep0, _mw0, "AdminListUserAuthEvents", AdminListUserAuthEvents$) {
}

class AdminRemoveUserFromGroupCommand extends command(_ep0, _mw0, "AdminRemoveUserFromGroup", AdminRemoveUserFromGroup$) {
}

class AdminResetUserPasswordCommand extends command(_ep0, _mw0, "AdminResetUserPassword", AdminResetUserPassword$) {
}

class AdminRespondToAuthChallengeCommand extends command(_ep0, _mw0, "AdminRespondToAuthChallenge", AdminRespondToAuthChallenge$) {
}

class AdminSetUserMFAPreferenceCommand extends command(_ep0, _mw0, "AdminSetUserMFAPreference", AdminSetUserMFAPreference$) {
}

class AdminSetUserPasswordCommand extends command(_ep0, _mw0, "AdminSetUserPassword", AdminSetUserPassword$) {
}

class AdminSetUserSettingsCommand extends command(_ep0, _mw0, "AdminSetUserSettings", AdminSetUserSettings$) {
}

class AdminUpdateAuthEventFeedbackCommand extends command(_ep0, _mw0, "AdminUpdateAuthEventFeedback", AdminUpdateAuthEventFeedback$) {
}

class AdminUpdateDeviceStatusCommand extends command(_ep0, _mw0, "AdminUpdateDeviceStatus", AdminUpdateDeviceStatus$) {
}

class AdminUpdateUserAttributesCommand extends command(_ep0, _mw0, "AdminUpdateUserAttributes", AdminUpdateUserAttributes$) {
}

class AdminUserGlobalSignOutCommand extends command(_ep0, _mw0, "AdminUserGlobalSignOut", AdminUserGlobalSignOut$) {
}

class AssociateSoftwareTokenCommand extends command(_ep0, _mw0, "AssociateSoftwareToken", AssociateSoftwareToken$) {
}

class ChangePasswordCommand extends command(_ep0, _mw0, "ChangePassword", ChangePassword$) {
}

class CompleteWebAuthnRegistrationCommand extends command(_ep0, _mw0, "CompleteWebAuthnRegistration", CompleteWebAuthnRegistration$) {
}

class ConfirmDeviceCommand extends command(_ep0, _mw0, "ConfirmDevice", ConfirmDevice$) {
}

class ConfirmForgotPasswordCommand extends command(_ep0, _mw0, "ConfirmForgotPassword", ConfirmForgotPassword$) {
}

class ConfirmSignUpCommand extends command(_ep0, _mw0, "ConfirmSignUp", ConfirmSignUp$) {
}

class CreateGroupCommand extends command(_ep0, _mw0, "CreateGroup", CreateGroup$) {
}

class CreateIdentityProviderCommand extends command(_ep0, _mw0, "CreateIdentityProvider", CreateIdentityProvider$) {
}

class CreateManagedLoginBrandingCommand extends command(_ep0, _mw0, "CreateManagedLoginBranding", CreateManagedLoginBranding$) {
}

class CreateResourceServerCommand extends command(_ep0, _mw0, "CreateResourceServer", CreateResourceServer$) {
}

class CreateTermsCommand extends command(_ep0, _mw0, "CreateTerms", CreateTerms$) {
}

class CreateUserImportJobCommand extends command(_ep0, _mw0, "CreateUserImportJob", CreateUserImportJob$) {
}

class CreateUserPoolClientCommand extends command(_ep0, _mw0, "CreateUserPoolClient", CreateUserPoolClient$) {
}

class CreateUserPoolCommand extends command(_ep0, _mw0, "CreateUserPool", CreateUserPool$) {
}

class CreateUserPoolDomainCommand extends command(_ep0, _mw0, "CreateUserPoolDomain", CreateUserPoolDomain$) {
}

class CreateUserPoolReplicaCommand extends command(_ep0, _mw0, "CreateUserPoolReplica", CreateUserPoolReplica$) {
}

class DeleteGroupCommand extends command(_ep0, _mw0, "DeleteGroup", DeleteGroup$) {
}

class DeleteIdentityProviderCommand extends command(_ep0, _mw0, "DeleteIdentityProvider", DeleteIdentityProvider$) {
}

class DeleteManagedLoginBrandingCommand extends command(_ep0, _mw0, "DeleteManagedLoginBranding", DeleteManagedLoginBranding$) {
}

class DeleteResourceServerCommand extends command(_ep0, _mw0, "DeleteResourceServer", DeleteResourceServer$) {
}

class DeleteTermsCommand extends command(_ep0, _mw0, "DeleteTerms", DeleteTerms$) {
}

class DeleteUserAttributesCommand extends command(_ep0, _mw0, "DeleteUserAttributes", DeleteUserAttributes$) {
}

class DeleteUserCommand extends command(_ep0, _mw0, "DeleteUser", DeleteUser$) {
}

class DeleteUserPoolClientCommand extends command(_ep0, _mw0, "DeleteUserPoolClient", DeleteUserPoolClient$) {
}

class DeleteUserPoolClientSecretCommand extends command(_ep0, _mw0, "DeleteUserPoolClientSecret", DeleteUserPoolClientSecret$) {
}

class DeleteUserPoolCommand extends command(_ep0, _mw0, "DeleteUserPool", DeleteUserPool$) {
}

class DeleteUserPoolDomainCommand extends command(_ep0, _mw0, "DeleteUserPoolDomain", DeleteUserPoolDomain$) {
}

class DeleteUserPoolReplicaCommand extends command(_ep0, _mw0, "DeleteUserPoolReplica", DeleteUserPoolReplica$) {
}

class DeleteWebAuthnCredentialCommand extends command(_ep0, _mw0, "DeleteWebAuthnCredential", DeleteWebAuthnCredential$) {
}

class DescribeIdentityProviderCommand extends command(_ep0, _mw0, "DescribeIdentityProvider", DescribeIdentityProvider$) {
}

class DescribeManagedLoginBrandingByClientCommand extends command(_ep0, _mw0, "DescribeManagedLoginBrandingByClient", DescribeManagedLoginBrandingByClient$) {
}

class DescribeManagedLoginBrandingCommand extends command(_ep0, _mw0, "DescribeManagedLoginBranding", DescribeManagedLoginBranding$) {
}

class DescribeResourceServerCommand extends command(_ep0, _mw0, "DescribeResourceServer", DescribeResourceServer$) {
}

class DescribeRiskConfigurationCommand extends command(_ep0, _mw0, "DescribeRiskConfiguration", DescribeRiskConfiguration$) {
}

class DescribeTermsByClientCommand extends command(_ep0, _mw0, "DescribeTermsByClient", DescribeTermsByClient$) {
}

class DescribeTermsCommand extends command(_ep0, _mw0, "DescribeTerms", DescribeTerms$) {
}

class DescribeUserImportJobCommand extends command(_ep0, _mw0, "DescribeUserImportJob", DescribeUserImportJob$) {
}

class DescribeUserPoolClientCommand extends command(_ep0, _mw0, "DescribeUserPoolClient", DescribeUserPoolClient$) {
}

class DescribeUserPoolCommand extends command(_ep0, _mw0, "DescribeUserPool", DescribeUserPool$) {
}

class DescribeUserPoolDomainCommand extends command(_ep0, _mw0, "DescribeUserPoolDomain", DescribeUserPoolDomain$) {
}

class ForgetDeviceCommand extends command(_ep0, _mw0, "ForgetDevice", ForgetDevice$) {
}

class ForgotPasswordCommand extends command(_ep0, _mw0, "ForgotPassword", ForgotPassword$) {
}

class GetClientTokenCommand extends command(_ep0, _mw0, "GetClientToken", GetClientToken$) {
}

class GetCSVHeaderCommand extends command(_ep0, _mw0, "GetCSVHeader", GetCSVHeader$) {
}

class GetDeviceCommand extends command(_ep0, _mw0, "GetDevice", GetDevice$) {
}

class GetGroupCommand extends command(_ep0, _mw0, "GetGroup", GetGroup$) {
}

class GetIdentityProviderByIdentifierCommand extends command(_ep0, _mw0, "GetIdentityProviderByIdentifier", GetIdentityProviderByIdentifier$) {
}

class GetLogDeliveryConfigurationCommand extends command(_ep0, _mw0, "GetLogDeliveryConfiguration", GetLogDeliveryConfiguration$) {
}

class GetProvisionedLimitCommand extends command(_ep0, _mw0, "GetProvisionedLimit", GetProvisionedLimit$) {
}

class GetSigningCertificateCommand extends command(_ep0, _mw0, "GetSigningCertificate", GetSigningCertificate$) {
}

class GetTokensFromRefreshTokenCommand extends command(_ep0, _mw0, "GetTokensFromRefreshToken", GetTokensFromRefreshToken$) {
}

class GetUICustomizationCommand extends command(_ep0, _mw0, "GetUICustomization", GetUICustomization$) {
}

class GetUserAttributeVerificationCodeCommand extends command(_ep0, _mw0, "GetUserAttributeVerificationCode", GetUserAttributeVerificationCode$) {
}

class GetUserAuthFactorsCommand extends command(_ep0, _mw0, "GetUserAuthFactors", GetUserAuthFactors$) {
}

class GetUserCommand extends command(_ep0, _mw0, "GetUser", GetUser$) {
}

class GetUserPoolMfaConfigCommand extends command(_ep0, _mw0, "GetUserPoolMfaConfig", GetUserPoolMfaConfig$) {
}

class GlobalSignOutCommand extends command(_ep0, _mw0, "GlobalSignOut", GlobalSignOut$) {
}

class InitiateAuthCommand extends command(_ep0, _mw0, "InitiateAuth", InitiateAuth$) {
}

class ListDevicesCommand extends command(_ep0, _mw0, "ListDevices", ListDevices$) {
}

class ListGroupsCommand extends command(_ep0, _mw0, "ListGroups", ListGroups$) {
}

class ListIdentityProvidersCommand extends command(_ep0, _mw0, "ListIdentityProviders", ListIdentityProviders$) {
}

class ListResourceServersCommand extends command(_ep0, _mw0, "ListResourceServers", ListResourceServers$) {
}

class ListTagsForResourceCommand extends command(_ep0, _mw0, "ListTagsForResource", ListTagsForResource$) {
}

class ListTermsCommand extends command(_ep0, _mw0, "ListTerms", ListTerms$) {
}

class ListUserImportJobsCommand extends command(_ep0, _mw0, "ListUserImportJobs", ListUserImportJobs$) {
}

class ListUserPoolClientsCommand extends command(_ep0, _mw0, "ListUserPoolClients", ListUserPoolClients$) {
}

class ListUserPoolClientSecretsCommand extends command(_ep0, _mw0, "ListUserPoolClientSecrets", ListUserPoolClientSecrets$) {
}

class ListUserPoolReplicasCommand extends command(_ep0, _mw0, "ListUserPoolReplicas", ListUserPoolReplicas$) {
}

class ListUserPoolsCommand extends command(_ep0, _mw0, "ListUserPools", ListUserPools$) {
}

class ListUsersCommand extends command(_ep0, _mw0, "ListUsers", ListUsers$) {
}

class ListUsersInGroupCommand extends command(_ep0, _mw0, "ListUsersInGroup", ListUsersInGroup$) {
}

class ListWebAuthnCredentialsCommand extends command(_ep0, _mw0, "ListWebAuthnCredentials", ListWebAuthnCredentials$) {
}

class ResendConfirmationCodeCommand extends command(_ep0, _mw0, "ResendConfirmationCode", ResendConfirmationCode$) {
}

class RespondToAuthChallengeCommand extends command(_ep0, _mw0, "RespondToAuthChallenge", RespondToAuthChallenge$) {
}

class RevokeTokenCommand extends command(_ep0, _mw0, "RevokeToken", RevokeToken$) {
}

class SetLogDeliveryConfigurationCommand extends command(_ep0, _mw0, "SetLogDeliveryConfiguration", SetLogDeliveryConfiguration$) {
}

class SetRiskConfigurationCommand extends command(_ep0, _mw0, "SetRiskConfiguration", SetRiskConfiguration$) {
}

class SetUICustomizationCommand extends command(_ep0, _mw0, "SetUICustomization", SetUICustomization$) {
}

class SetUserMFAPreferenceCommand extends command(_ep0, _mw0, "SetUserMFAPreference", SetUserMFAPreference$) {
}

class SetUserPoolMfaConfigCommand extends command(_ep0, _mw0, "SetUserPoolMfaConfig", SetUserPoolMfaConfig$) {
}

class SetUserSettingsCommand extends command(_ep0, _mw0, "SetUserSettings", SetUserSettings$) {
}

class SignUpCommand extends command(_ep0, _mw0, "SignUp", SignUp$) {
}

class StartUserImportJobCommand extends command(_ep0, _mw0, "StartUserImportJob", StartUserImportJob$) {
}

class StartWebAuthnRegistrationCommand extends command(_ep0, _mw0, "StartWebAuthnRegistration", StartWebAuthnRegistration$) {
}

class StopUserImportJobCommand extends command(_ep0, _mw0, "StopUserImportJob", StopUserImportJob$) {
}

class TagResourceCommand extends command(_ep0, _mw0, "TagResource", TagResource$) {
}

class UntagResourceCommand extends command(_ep0, _mw0, "UntagResource", UntagResource$) {
}

class UpdateAuthEventFeedbackCommand extends command(_ep0, _mw0, "UpdateAuthEventFeedback", UpdateAuthEventFeedback$) {
}

class UpdateDeviceStatusCommand extends command(_ep0, _mw0, "UpdateDeviceStatus", UpdateDeviceStatus$) {
}

class UpdateGroupCommand extends command(_ep0, _mw0, "UpdateGroup", UpdateGroup$) {
}

class UpdateIdentityProviderCommand extends command(_ep0, _mw0, "UpdateIdentityProvider", UpdateIdentityProvider$) {
}

class UpdateManagedLoginBrandingCommand extends command(_ep0, _mw0, "UpdateManagedLoginBranding", UpdateManagedLoginBranding$) {
}

class UpdateProvisionedLimitCommand extends command(_ep0, _mw0, "UpdateProvisionedLimit", UpdateProvisionedLimit$) {
}

class UpdateResourceServerCommand extends command(_ep0, _mw0, "UpdateResourceServer", UpdateResourceServer$) {
}

class UpdateTermsCommand extends command(_ep0, _mw0, "UpdateTerms", UpdateTerms$) {
}

class UpdateUserAttributesCommand extends command(_ep0, _mw0, "UpdateUserAttributes", UpdateUserAttributes$) {
}

class UpdateUserPoolClientCommand extends command(_ep0, _mw0, "UpdateUserPoolClient", UpdateUserPoolClient$) {
}

class UpdateUserPoolCommand extends command(_ep0, _mw0, "UpdateUserPool", UpdateUserPool$) {
}

class UpdateUserPoolDomainCommand extends command(_ep0, _mw0, "UpdateUserPoolDomain", UpdateUserPoolDomain$) {
}

class UpdateUserPoolReplicaCommand extends command(_ep0, _mw0, "UpdateUserPoolReplica", UpdateUserPoolReplica$) {
}

class VerifySoftwareTokenCommand extends command(_ep0, _mw0, "VerifySoftwareToken", VerifySoftwareToken$) {
}

class VerifyUserAttributeCommand extends command(_ep0, _mw0, "VerifyUserAttribute", VerifyUserAttribute$) {
}

const paginateAdminListGroupsForUser = createPaginator(CognitoIdentityProviderClient, AdminListGroupsForUserCommand, "NextToken", "NextToken", "Limit");

const paginateAdminListUserAuthEvents = createPaginator(CognitoIdentityProviderClient, AdminListUserAuthEventsCommand, "NextToken", "NextToken", "MaxResults");

const paginateListGroups = createPaginator(CognitoIdentityProviderClient, ListGroupsCommand, "NextToken", "NextToken", "Limit");

const paginateListIdentityProviders = createPaginator(CognitoIdentityProviderClient, ListIdentityProvidersCommand, "NextToken", "NextToken", "MaxResults");

const paginateListResourceServers = createPaginator(CognitoIdentityProviderClient, ListResourceServersCommand, "NextToken", "NextToken", "MaxResults");

const paginateListUserPoolClients = createPaginator(CognitoIdentityProviderClient, ListUserPoolClientsCommand, "NextToken", "NextToken", "MaxResults");

const paginateListUserPools = createPaginator(CognitoIdentityProviderClient, ListUserPoolsCommand, "NextToken", "NextToken", "MaxResults");

const paginateListUsersInGroup = createPaginator(CognitoIdentityProviderClient, ListUsersInGroupCommand, "NextToken", "NextToken", "Limit");

const paginateListUsers = createPaginator(CognitoIdentityProviderClient, ListUsersCommand, "PaginationToken", "PaginationToken", "Limit");

const commands = {
    AddCustomAttributesCommand,
    AddUserPoolClientSecretCommand,
    AdminAddUserToGroupCommand,
    AdminConfirmSignUpCommand,
    AdminCreateUserCommand,
    AdminDeleteSoftwareTokenCommand,
    AdminDeleteUserCommand,
    AdminDeleteUserAttributesCommand,
    AdminDisableProviderForUserCommand,
    AdminDisableUserCommand,
    AdminEnableUserCommand,
    AdminForgetDeviceCommand,
    AdminGetDeviceCommand,
    AdminGetUserCommand,
    AdminGetUserAuthFactorsCommand,
    AdminInitiateAuthCommand,
    AdminLinkProviderForUserCommand,
    AdminListDevicesCommand,
    AdminListGroupsForUserCommand,
    AdminListUserAuthEventsCommand,
    AdminRemoveUserFromGroupCommand,
    AdminResetUserPasswordCommand,
    AdminRespondToAuthChallengeCommand,
    AdminSetUserMFAPreferenceCommand,
    AdminSetUserPasswordCommand,
    AdminSetUserSettingsCommand,
    AdminUpdateAuthEventFeedbackCommand,
    AdminUpdateDeviceStatusCommand,
    AdminUpdateUserAttributesCommand,
    AdminUserGlobalSignOutCommand,
    AssociateSoftwareTokenCommand,
    ChangePasswordCommand,
    CompleteWebAuthnRegistrationCommand,
    ConfirmDeviceCommand,
    ConfirmForgotPasswordCommand,
    ConfirmSignUpCommand,
    CreateGroupCommand,
    CreateIdentityProviderCommand,
    CreateManagedLoginBrandingCommand,
    CreateResourceServerCommand,
    CreateTermsCommand,
    CreateUserImportJobCommand,
    CreateUserPoolCommand,
    CreateUserPoolClientCommand,
    CreateUserPoolDomainCommand,
    CreateUserPoolReplicaCommand,
    DeleteGroupCommand,
    DeleteIdentityProviderCommand,
    DeleteManagedLoginBrandingCommand,
    DeleteResourceServerCommand,
    DeleteTermsCommand,
    DeleteUserCommand,
    DeleteUserAttributesCommand,
    DeleteUserPoolCommand,
    DeleteUserPoolClientCommand,
    DeleteUserPoolClientSecretCommand,
    DeleteUserPoolDomainCommand,
    DeleteUserPoolReplicaCommand,
    DeleteWebAuthnCredentialCommand,
    DescribeIdentityProviderCommand,
    DescribeManagedLoginBrandingCommand,
    DescribeManagedLoginBrandingByClientCommand,
    DescribeResourceServerCommand,
    DescribeRiskConfigurationCommand,
    DescribeTermsCommand,
    DescribeTermsByClientCommand,
    DescribeUserImportJobCommand,
    DescribeUserPoolCommand,
    DescribeUserPoolClientCommand,
    DescribeUserPoolDomainCommand,
    ForgetDeviceCommand,
    ForgotPasswordCommand,
    GetClientTokenCommand,
    GetCSVHeaderCommand,
    GetDeviceCommand,
    GetGroupCommand,
    GetIdentityProviderByIdentifierCommand,
    GetLogDeliveryConfigurationCommand,
    GetProvisionedLimitCommand,
    GetSigningCertificateCommand,
    GetTokensFromRefreshTokenCommand,
    GetUICustomizationCommand,
    GetUserCommand,
    GetUserAttributeVerificationCodeCommand,
    GetUserAuthFactorsCommand,
    GetUserPoolMfaConfigCommand,
    GlobalSignOutCommand,
    InitiateAuthCommand,
    ListDevicesCommand,
    ListGroupsCommand,
    ListIdentityProvidersCommand,
    ListResourceServersCommand,
    ListTagsForResourceCommand,
    ListTermsCommand,
    ListUserImportJobsCommand,
    ListUserPoolClientsCommand,
    ListUserPoolClientSecretsCommand,
    ListUserPoolReplicasCommand,
    ListUserPoolsCommand,
    ListUsersCommand,
    ListUsersInGroupCommand,
    ListWebAuthnCredentialsCommand,
    ResendConfirmationCodeCommand,
    RespondToAuthChallengeCommand,
    RevokeTokenCommand,
    SetLogDeliveryConfigurationCommand,
    SetRiskConfigurationCommand,
    SetUICustomizationCommand,
    SetUserMFAPreferenceCommand,
    SetUserPoolMfaConfigCommand,
    SetUserSettingsCommand,
    SignUpCommand,
    StartUserImportJobCommand,
    StartWebAuthnRegistrationCommand,
    StopUserImportJobCommand,
    TagResourceCommand,
    UntagResourceCommand,
    UpdateAuthEventFeedbackCommand,
    UpdateDeviceStatusCommand,
    UpdateGroupCommand,
    UpdateIdentityProviderCommand,
    UpdateManagedLoginBrandingCommand,
    UpdateProvisionedLimitCommand,
    UpdateResourceServerCommand,
    UpdateTermsCommand,
    UpdateUserAttributesCommand,
    UpdateUserPoolCommand,
    UpdateUserPoolClientCommand,
    UpdateUserPoolDomainCommand,
    UpdateUserPoolReplicaCommand,
    VerifySoftwareTokenCommand,
    VerifyUserAttributeCommand,
};
const paginators = {
    paginateAdminListGroupsForUser,
    paginateAdminListUserAuthEvents,
    paginateListGroups,
    paginateListIdentityProviders,
    paginateListResourceServers,
    paginateListUserPoolClients,
    paginateListUserPools,
    paginateListUsers,
    paginateListUsersInGroup,
};
class CognitoIdentityProvider extends CognitoIdentityProviderClient {
}
createAggregatedClient(commands, CognitoIdentityProvider, { paginators });

const RecoveryOptionNameType = {
    ADMIN_ONLY: "admin_only",
    VERIFIED_EMAIL: "verified_email",
    VERIFIED_PHONE_NUMBER: "verified_phone_number",
};
const AccountTakeoverEventActionType = {
    BLOCK: "BLOCK",
    MFA_IF_CONFIGURED: "MFA_IF_CONFIGURED",
    MFA_REQUIRED: "MFA_REQUIRED",
    NO_ACTION: "NO_ACTION",
};
const AttributeDataType = {
    BOOLEAN: "Boolean",
    DATETIME: "DateTime",
    NUMBER: "Number",
    STRING: "String",
};
const DeliveryMediumType = {
    EMAIL: "EMAIL",
    SMS: "SMS",
};
const MessageActionType = {
    RESEND: "RESEND",
    SUPPRESS: "SUPPRESS",
};
const UserStatusType = {
    ARCHIVED: "ARCHIVED",
    COMPROMISED: "COMPROMISED",
    CONFIRMED: "CONFIRMED",
    EXTERNAL_PROVIDER: "EXTERNAL_PROVIDER",
    FORCE_CHANGE_PASSWORD: "FORCE_CHANGE_PASSWORD",
    RESET_REQUIRED: "RESET_REQUIRED",
    UNCONFIRMED: "UNCONFIRMED",
    UNKNOWN: "UNKNOWN",
};
const AuthFactorType = {
    EMAIL_OTP: "EMAIL_OTP",
    PASSWORD: "PASSWORD",
    SMS_OTP: "SMS_OTP",
    SOFTWARE_TOKEN: "SOFTWARE_TOKEN",
    WEB_AUTHN: "WEB_AUTHN",
};
const AuthFlowType = {
    ADMIN_NO_SRP_AUTH: "ADMIN_NO_SRP_AUTH",
    ADMIN_USER_PASSWORD_AUTH: "ADMIN_USER_PASSWORD_AUTH",
    CUSTOM_AUTH: "CUSTOM_AUTH",
    REFRESH_TOKEN: "REFRESH_TOKEN",
    REFRESH_TOKEN_AUTH: "REFRESH_TOKEN_AUTH",
    USER_AUTH: "USER_AUTH",
    USER_PASSWORD_AUTH: "USER_PASSWORD_AUTH",
    USER_SRP_AUTH: "USER_SRP_AUTH",
};
const ChallengeNameType = {
    ADMIN_NO_SRP_AUTH: "ADMIN_NO_SRP_AUTH",
    CUSTOM_CHALLENGE: "CUSTOM_CHALLENGE",
    DEVICE_PASSWORD_VERIFIER: "DEVICE_PASSWORD_VERIFIER",
    DEVICE_SRP_AUTH: "DEVICE_SRP_AUTH",
    EMAIL_OTP: "EMAIL_OTP",
    MFA_SETUP: "MFA_SETUP",
    NEW_PASSWORD_REQUIRED: "NEW_PASSWORD_REQUIRED",
    PASSWORD: "PASSWORD",
    PASSWORD_SRP: "PASSWORD_SRP",
    PASSWORD_VERIFIER: "PASSWORD_VERIFIER",
    SELECT_CHALLENGE: "SELECT_CHALLENGE",
    SELECT_MFA_TYPE: "SELECT_MFA_TYPE",
    SMS_MFA: "SMS_MFA",
    SMS_OTP: "SMS_OTP",
    SOFTWARE_TOKEN_MFA: "SOFTWARE_TOKEN_MFA",
    WEB_AUTHN: "WEB_AUTHN",
};
const ChallengeName = {
    Mfa: "Mfa",
    Password: "Password",
};
const ChallengeResponse = {
    Failure: "Failure",
    Success: "Success",
};
const FeedbackValueType = {
    INVALID: "Invalid",
    VALID: "Valid",
};
const EventResponseType = {
    Fail: "Fail",
    InProgress: "InProgress",
    Pass: "Pass",
};
const RiskDecisionType = {
    AccountTakeover: "AccountTakeover",
    Block: "Block",
    NoRisk: "NoRisk",
};
const RiskLevelType = {
    High: "High",
    Low: "Low",
    Medium: "Medium",
};
const EventType = {
    ForgotPassword: "ForgotPassword",
    PasswordChange: "PasswordChange",
    ResendCode: "ResendCode",
    SignIn: "SignIn",
    SignUp: "SignUp",
};
const DeviceRememberedStatusType = {
    NOT_REMEMBERED: "not_remembered",
    REMEMBERED: "remembered",
};
const AdvancedSecurityEnabledModeType = {
    AUDIT: "AUDIT",
    ENFORCED: "ENFORCED",
};
const AdvancedSecurityModeType = {
    AUDIT: "AUDIT",
    ENFORCED: "ENFORCED",
    OFF: "OFF",
};
const AliasAttributeType = {
    EMAIL: "email",
    PHONE_NUMBER: "phone_number",
    PREFERRED_USERNAME: "preferred_username",
};
const AssetCategoryType = {
    AUTH_APP_GRAPHIC: "AUTH_APP_GRAPHIC",
    EMAIL_GRAPHIC: "EMAIL_GRAPHIC",
    FAVICON_ICO: "FAVICON_ICO",
    FAVICON_SVG: "FAVICON_SVG",
    FORM_BACKGROUND: "FORM_BACKGROUND",
    FORM_LOGO: "FORM_LOGO",
    IDP_BUTTON_ICON: "IDP_BUTTON_ICON",
    PAGE_BACKGROUND: "PAGE_BACKGROUND",
    PAGE_FOOTER_BACKGROUND: "PAGE_FOOTER_BACKGROUND",
    PAGE_FOOTER_LOGO: "PAGE_FOOTER_LOGO",
    PAGE_HEADER_BACKGROUND: "PAGE_HEADER_BACKGROUND",
    PAGE_HEADER_LOGO: "PAGE_HEADER_LOGO",
    PASSKEY_GRAPHIC: "PASSKEY_GRAPHIC",
    PASSWORD_GRAPHIC: "PASSWORD_GRAPHIC",
    SMS_GRAPHIC: "SMS_GRAPHIC",
};
const AssetExtensionType = {
    ICO: "ICO",
    JPEG: "JPEG",
    PNG: "PNG",
    SVG: "SVG",
    WEBP: "WEBP",
};
const ColorSchemeModeType = {
    DARK: "DARK",
    DYNAMIC: "DYNAMIC",
    LIGHT: "LIGHT",
};
const VerifiedAttributeType = {
    EMAIL: "email",
    PHONE_NUMBER: "phone_number",
};
const IdentityProviderTypeType = {
    Facebook: "Facebook",
    Google: "Google",
    LoginWithAmazon: "LoginWithAmazon",
    OIDC: "OIDC",
    SAML: "SAML",
    SignInWithApple: "SignInWithApple",
};
const TermsEnforcementType = {
    NONE: "NONE",
};
const TermsSourceType = {
    LINK: "LINK",
};
const PasswordHashingAlgorithmType = {
    ARGON2ID: "ARGON2ID",
    BCRYPT: "BCRYPT",
    PBKDF2_SHA256: "PBKDF2_SHA256",
    SCRYPT: "SCRYPT",
};
const UserImportJobStatusType = {
    Created: "Created",
    Expired: "Expired",
    Failed: "Failed",
    InProgress: "InProgress",
    Pending: "Pending",
    Stopped: "Stopped",
    Stopping: "Stopping",
    Succeeded: "Succeeded",
};
const DeletionProtectionType = {
    ACTIVE: "ACTIVE",
    INACTIVE: "INACTIVE",
};
const EmailSendingAccountType = {
    COGNITO_DEFAULT: "COGNITO_DEFAULT",
    DEVELOPER: "DEVELOPER",
};
const IssuerType = {
    ORIGINAL: "ORIGINAL",
    UPDATED: "UPDATED",
};
const EncryptionKeyType = {
    AWS_OWNED_KEY: "AWS_OWNED_KEY",
    CUSTOMER_MANAGED_KEY: "CUSTOMER_MANAGED_KEY",
};
const CustomEmailSenderLambdaVersionType = {
    V1_0: "V1_0",
};
const CustomSMSSenderLambdaVersionType = {
    V1_0: "V1_0",
};
const InboundFederationLambdaVersionType = {
    V1_0: "V1_0",
};
const PreTokenGenerationLambdaVersionType = {
    V1_0: "V1_0",
    V2_0: "V2_0",
    V3_0: "V3_0",
};
const UserPoolMfaType = {
    OFF: "OFF",
    ON: "ON",
    OPTIONAL: "OPTIONAL",
};
const UsernameAttributeType = {
    EMAIL: "email",
    PHONE_NUMBER: "phone_number",
};
const UserPoolTierType = {
    ESSENTIALS: "ESSENTIALS",
    LITE: "LITE",
    PLUS: "PLUS",
};
const DefaultEmailOptionType = {
    CONFIRM_WITH_CODE: "CONFIRM_WITH_CODE",
    CONFIRM_WITH_LINK: "CONFIRM_WITH_LINK",
};
const StatusType = {
    Disabled: "Disabled",
    Enabled: "Enabled",
};
const OAuthFlowType = {
    client_credentials: "client_credentials",
    code: "code",
    implicit: "implicit",
};
const ExplicitAuthFlowsType = {
    ADMIN_NO_SRP_AUTH: "ADMIN_NO_SRP_AUTH",
    ALLOW_ADMIN_USER_PASSWORD_AUTH: "ALLOW_ADMIN_USER_PASSWORD_AUTH",
    ALLOW_CUSTOM_AUTH: "ALLOW_CUSTOM_AUTH",
    ALLOW_REFRESH_TOKEN_AUTH: "ALLOW_REFRESH_TOKEN_AUTH",
    ALLOW_USER_AUTH: "ALLOW_USER_AUTH",
    ALLOW_USER_PASSWORD_AUTH: "ALLOW_USER_PASSWORD_AUTH",
    ALLOW_USER_SRP_AUTH: "ALLOW_USER_SRP_AUTH",
    CUSTOM_AUTH_FLOW_ONLY: "CUSTOM_AUTH_FLOW_ONLY",
    USER_PASSWORD_AUTH: "USER_PASSWORD_AUTH",
};
const PreventUserExistenceErrorTypes = {
    ENABLED: "ENABLED",
    LEGACY: "LEGACY",
};
const FeatureType = {
    DISABLED: "DISABLED",
    ENABLED: "ENABLED",
};
const TimeUnitsType = {
    DAYS: "days",
    HOURS: "hours",
    MINUTES: "minutes",
    SECONDS: "seconds",
};
const SecurityPolicyType = {
    TLS_V1: "TLS_V1",
    TLS_V1_2_2021: "TLS_V1_2_2021",
    TLS_V1_3_2025: "TLS_V1_3_2025",
};
const ReplicaRoleType = {
    PRIMARY: "PRIMARY",
    SECONDARY: "SECONDARY",
};
const ReplicaStatusType = {
    ACTIVE: "ACTIVE",
    CREATING: "CREATING",
    DELETING: "DELETING",
    INACTIVE: "INACTIVE",
};
const CompromisedCredentialsEventActionType = {
    BLOCK: "BLOCK",
    NO_ACTION: "NO_ACTION",
};
const EventFilterType = {
    PASSWORD_CHANGE: "PASSWORD_CHANGE",
    SIGN_IN: "SIGN_IN",
    SIGN_UP: "SIGN_UP",
};
const DomainStatusType = {
    ACTIVE: "ACTIVE",
    CREATING: "CREATING",
    DELETING: "DELETING",
    FAILED: "FAILED",
    UPDATING: "UPDATING",
};
const EventSourceName = {
    USER_AUTH_EVENTS: "userAuthEvents",
    USER_NOTIFICATION: "userNotification",
};
const LogLevel = {
    ERROR: "ERROR",
    INFO: "INFO",
};
const LimitClass = {
    API_CATEGORY: "API_CATEGORY",
};
const WebAuthnFactorConfigurationType = {
    MULTI_FACTOR_WITH_USER_VERIFICATION: "MULTI_FACTOR_WITH_USER_VERIFICATION",
    SINGLE_FACTOR: "SINGLE_FACTOR",
};
const UserVerificationType = {
    PREFERRED: "preferred",
    REQUIRED: "required",
};
const UpdateReplicaStatusType = {
    ACTIVE: "ACTIVE",
    INACTIVE: "INACTIVE",
};
const VerifySoftwareTokenResponseType = {
    ERROR: "ERROR",
    SUCCESS: "SUCCESS",
};

exports.AccessDeniedException = AccessDeniedException;
exports.AccessDeniedException$ = AccessDeniedException$;
exports.AccountRecoverySettingType$ = AccountRecoverySettingType$;
exports.AccountTakeoverActionType$ = AccountTakeoverActionType$;
exports.AccountTakeoverActionsType$ = AccountTakeoverActionsType$;
exports.AccountTakeoverEventActionType = AccountTakeoverEventActionType;
exports.AccountTakeoverRiskConfigurationType$ = AccountTakeoverRiskConfigurationType$;
exports.AddCustomAttributes$ = AddCustomAttributes$;
exports.AddCustomAttributesCommand = AddCustomAttributesCommand;
exports.AddCustomAttributesRequest$ = AddCustomAttributesRequest$;
exports.AddCustomAttributesResponse$ = AddCustomAttributesResponse$;
exports.AddUserPoolClientSecret$ = AddUserPoolClientSecret$;
exports.AddUserPoolClientSecretCommand = AddUserPoolClientSecretCommand;
exports.AddUserPoolClientSecretRequest$ = AddUserPoolClientSecretRequest$;
exports.AddUserPoolClientSecretResponse$ = AddUserPoolClientSecretResponse$;
exports.AdminAddUserToGroup$ = AdminAddUserToGroup$;
exports.AdminAddUserToGroupCommand = AdminAddUserToGroupCommand;
exports.AdminAddUserToGroupRequest$ = AdminAddUserToGroupRequest$;
exports.AdminConfirmSignUp$ = AdminConfirmSignUp$;
exports.AdminConfirmSignUpCommand = AdminConfirmSignUpCommand;
exports.AdminConfirmSignUpRequest$ = AdminConfirmSignUpRequest$;
exports.AdminConfirmSignUpResponse$ = AdminConfirmSignUpResponse$;
exports.AdminCreateUser$ = AdminCreateUser$;
exports.AdminCreateUserCommand = AdminCreateUserCommand;
exports.AdminCreateUserConfigType$ = AdminCreateUserConfigType$;
exports.AdminCreateUserRequest$ = AdminCreateUserRequest$;
exports.AdminCreateUserResponse$ = AdminCreateUserResponse$;
exports.AdminDeleteSoftwareToken$ = AdminDeleteSoftwareToken$;
exports.AdminDeleteSoftwareTokenCommand = AdminDeleteSoftwareTokenCommand;
exports.AdminDeleteSoftwareTokenRequest$ = AdminDeleteSoftwareTokenRequest$;
exports.AdminDeleteSoftwareTokenResponse$ = AdminDeleteSoftwareTokenResponse$;
exports.AdminDeleteUser$ = AdminDeleteUser$;
exports.AdminDeleteUserAttributes$ = AdminDeleteUserAttributes$;
exports.AdminDeleteUserAttributesCommand = AdminDeleteUserAttributesCommand;
exports.AdminDeleteUserAttributesRequest$ = AdminDeleteUserAttributesRequest$;
exports.AdminDeleteUserAttributesResponse$ = AdminDeleteUserAttributesResponse$;
exports.AdminDeleteUserCommand = AdminDeleteUserCommand;
exports.AdminDeleteUserRequest$ = AdminDeleteUserRequest$;
exports.AdminDisableProviderForUser$ = AdminDisableProviderForUser$;
exports.AdminDisableProviderForUserCommand = AdminDisableProviderForUserCommand;
exports.AdminDisableProviderForUserRequest$ = AdminDisableProviderForUserRequest$;
exports.AdminDisableProviderForUserResponse$ = AdminDisableProviderForUserResponse$;
exports.AdminDisableUser$ = AdminDisableUser$;
exports.AdminDisableUserCommand = AdminDisableUserCommand;
exports.AdminDisableUserRequest$ = AdminDisableUserRequest$;
exports.AdminDisableUserResponse$ = AdminDisableUserResponse$;
exports.AdminEnableUser$ = AdminEnableUser$;
exports.AdminEnableUserCommand = AdminEnableUserCommand;
exports.AdminEnableUserRequest$ = AdminEnableUserRequest$;
exports.AdminEnableUserResponse$ = AdminEnableUserResponse$;
exports.AdminForgetDevice$ = AdminForgetDevice$;
exports.AdminForgetDeviceCommand = AdminForgetDeviceCommand;
exports.AdminForgetDeviceRequest$ = AdminForgetDeviceRequest$;
exports.AdminGetDevice$ = AdminGetDevice$;
exports.AdminGetDeviceCommand = AdminGetDeviceCommand;
exports.AdminGetDeviceRequest$ = AdminGetDeviceRequest$;
exports.AdminGetDeviceResponse$ = AdminGetDeviceResponse$;
exports.AdminGetUser$ = AdminGetUser$;
exports.AdminGetUserAuthFactors$ = AdminGetUserAuthFactors$;
exports.AdminGetUserAuthFactorsCommand = AdminGetUserAuthFactorsCommand;
exports.AdminGetUserAuthFactorsRequest$ = AdminGetUserAuthFactorsRequest$;
exports.AdminGetUserAuthFactorsResponse$ = AdminGetUserAuthFactorsResponse$;
exports.AdminGetUserCommand = AdminGetUserCommand;
exports.AdminGetUserRequest$ = AdminGetUserRequest$;
exports.AdminGetUserResponse$ = AdminGetUserResponse$;
exports.AdminInitiateAuth$ = AdminInitiateAuth$;
exports.AdminInitiateAuthCommand = AdminInitiateAuthCommand;
exports.AdminInitiateAuthRequest$ = AdminInitiateAuthRequest$;
exports.AdminInitiateAuthResponse$ = AdminInitiateAuthResponse$;
exports.AdminLinkProviderForUser$ = AdminLinkProviderForUser$;
exports.AdminLinkProviderForUserCommand = AdminLinkProviderForUserCommand;
exports.AdminLinkProviderForUserRequest$ = AdminLinkProviderForUserRequest$;
exports.AdminLinkProviderForUserResponse$ = AdminLinkProviderForUserResponse$;
exports.AdminListDevices$ = AdminListDevices$;
exports.AdminListDevicesCommand = AdminListDevicesCommand;
exports.AdminListDevicesRequest$ = AdminListDevicesRequest$;
exports.AdminListDevicesResponse$ = AdminListDevicesResponse$;
exports.AdminListGroupsForUser$ = AdminListGroupsForUser$;
exports.AdminListGroupsForUserCommand = AdminListGroupsForUserCommand;
exports.AdminListGroupsForUserRequest$ = AdminListGroupsForUserRequest$;
exports.AdminListGroupsForUserResponse$ = AdminListGroupsForUserResponse$;
exports.AdminListUserAuthEvents$ = AdminListUserAuthEvents$;
exports.AdminListUserAuthEventsCommand = AdminListUserAuthEventsCommand;
exports.AdminListUserAuthEventsRequest$ = AdminListUserAuthEventsRequest$;
exports.AdminListUserAuthEventsResponse$ = AdminListUserAuthEventsResponse$;
exports.AdminRemoveUserFromGroup$ = AdminRemoveUserFromGroup$;
exports.AdminRemoveUserFromGroupCommand = AdminRemoveUserFromGroupCommand;
exports.AdminRemoveUserFromGroupRequest$ = AdminRemoveUserFromGroupRequest$;
exports.AdminResetUserPassword$ = AdminResetUserPassword$;
exports.AdminResetUserPasswordCommand = AdminResetUserPasswordCommand;
exports.AdminResetUserPasswordRequest$ = AdminResetUserPasswordRequest$;
exports.AdminResetUserPasswordResponse$ = AdminResetUserPasswordResponse$;
exports.AdminRespondToAuthChallenge$ = AdminRespondToAuthChallenge$;
exports.AdminRespondToAuthChallengeCommand = AdminRespondToAuthChallengeCommand;
exports.AdminRespondToAuthChallengeRequest$ = AdminRespondToAuthChallengeRequest$;
exports.AdminRespondToAuthChallengeResponse$ = AdminRespondToAuthChallengeResponse$;
exports.AdminSetUserMFAPreference$ = AdminSetUserMFAPreference$;
exports.AdminSetUserMFAPreferenceCommand = AdminSetUserMFAPreferenceCommand;
exports.AdminSetUserMFAPreferenceRequest$ = AdminSetUserMFAPreferenceRequest$;
exports.AdminSetUserMFAPreferenceResponse$ = AdminSetUserMFAPreferenceResponse$;
exports.AdminSetUserPassword$ = AdminSetUserPassword$;
exports.AdminSetUserPasswordCommand = AdminSetUserPasswordCommand;
exports.AdminSetUserPasswordRequest$ = AdminSetUserPasswordRequest$;
exports.AdminSetUserPasswordResponse$ = AdminSetUserPasswordResponse$;
exports.AdminSetUserSettings$ = AdminSetUserSettings$;
exports.AdminSetUserSettingsCommand = AdminSetUserSettingsCommand;
exports.AdminSetUserSettingsRequest$ = AdminSetUserSettingsRequest$;
exports.AdminSetUserSettingsResponse$ = AdminSetUserSettingsResponse$;
exports.AdminUpdateAuthEventFeedback$ = AdminUpdateAuthEventFeedback$;
exports.AdminUpdateAuthEventFeedbackCommand = AdminUpdateAuthEventFeedbackCommand;
exports.AdminUpdateAuthEventFeedbackRequest$ = AdminUpdateAuthEventFeedbackRequest$;
exports.AdminUpdateAuthEventFeedbackResponse$ = AdminUpdateAuthEventFeedbackResponse$;
exports.AdminUpdateDeviceStatus$ = AdminUpdateDeviceStatus$;
exports.AdminUpdateDeviceStatusCommand = AdminUpdateDeviceStatusCommand;
exports.AdminUpdateDeviceStatusRequest$ = AdminUpdateDeviceStatusRequest$;
exports.AdminUpdateDeviceStatusResponse$ = AdminUpdateDeviceStatusResponse$;
exports.AdminUpdateUserAttributes$ = AdminUpdateUserAttributes$;
exports.AdminUpdateUserAttributesCommand = AdminUpdateUserAttributesCommand;
exports.AdminUpdateUserAttributesRequest$ = AdminUpdateUserAttributesRequest$;
exports.AdminUpdateUserAttributesResponse$ = AdminUpdateUserAttributesResponse$;
exports.AdminUserGlobalSignOut$ = AdminUserGlobalSignOut$;
exports.AdminUserGlobalSignOutCommand = AdminUserGlobalSignOutCommand;
exports.AdminUserGlobalSignOutRequest$ = AdminUserGlobalSignOutRequest$;
exports.AdminUserGlobalSignOutResponse$ = AdminUserGlobalSignOutResponse$;
exports.AdvancedSecurityAdditionalFlowsType$ = AdvancedSecurityAdditionalFlowsType$;
exports.AdvancedSecurityEnabledModeType = AdvancedSecurityEnabledModeType;
exports.AdvancedSecurityModeType = AdvancedSecurityModeType;
exports.AliasAttributeType = AliasAttributeType;
exports.AliasExistsException = AliasExistsException;
exports.AliasExistsException$ = AliasExistsException$;
exports.AnalyticsConfigurationType$ = AnalyticsConfigurationType$;
exports.AnalyticsMetadataType$ = AnalyticsMetadataType$;
exports.AssetCategoryType = AssetCategoryType;
exports.AssetExtensionType = AssetExtensionType;
exports.AssetType$ = AssetType$;
exports.AssociateSoftwareToken$ = AssociateSoftwareToken$;
exports.AssociateSoftwareTokenCommand = AssociateSoftwareTokenCommand;
exports.AssociateSoftwareTokenRequest$ = AssociateSoftwareTokenRequest$;
exports.AssociateSoftwareTokenResponse$ = AssociateSoftwareTokenResponse$;
exports.AttributeDataType = AttributeDataType;
exports.AttributeType$ = AttributeType$;
exports.AuthEventType$ = AuthEventType$;
exports.AuthFactorType = AuthFactorType;
exports.AuthFlowType = AuthFlowType;
exports.AuthenticationResultType$ = AuthenticationResultType$;
exports.ChallengeName = ChallengeName;
exports.ChallengeNameType = ChallengeNameType;
exports.ChallengeResponse = ChallengeResponse;
exports.ChallengeResponseType$ = ChallengeResponseType$;
exports.ChangePassword$ = ChangePassword$;
exports.ChangePasswordCommand = ChangePasswordCommand;
exports.ChangePasswordRequest$ = ChangePasswordRequest$;
exports.ChangePasswordResponse$ = ChangePasswordResponse$;
exports.ClientAuthenticationResultType$ = ClientAuthenticationResultType$;
exports.ClientSecretDescriptorType$ = ClientSecretDescriptorType$;
exports.CloudWatchLogsConfigurationType$ = CloudWatchLogsConfigurationType$;
exports.CodeDeliveryDetailsType$ = CodeDeliveryDetailsType$;
exports.CodeDeliveryFailureException = CodeDeliveryFailureException;
exports.CodeDeliveryFailureException$ = CodeDeliveryFailureException$;
exports.CodeMismatchException = CodeMismatchException;
exports.CodeMismatchException$ = CodeMismatchException$;
exports.CognitoIdentityProvider = CognitoIdentityProvider;
exports.CognitoIdentityProviderClient = CognitoIdentityProviderClient;
exports.CognitoIdentityProviderServiceException = CognitoIdentityProviderServiceException;
exports.CognitoIdentityProviderServiceException$ = CognitoIdentityProviderServiceException$;
exports.ColorSchemeModeType = ColorSchemeModeType;
exports.CompleteWebAuthnRegistration$ = CompleteWebAuthnRegistration$;
exports.CompleteWebAuthnRegistrationCommand = CompleteWebAuthnRegistrationCommand;
exports.CompleteWebAuthnRegistrationRequest$ = CompleteWebAuthnRegistrationRequest$;
exports.CompleteWebAuthnRegistrationResponse$ = CompleteWebAuthnRegistrationResponse$;
exports.CompromisedCredentialsActionsType$ = CompromisedCredentialsActionsType$;
exports.CompromisedCredentialsEventActionType = CompromisedCredentialsEventActionType;
exports.CompromisedCredentialsRiskConfigurationType$ = CompromisedCredentialsRiskConfigurationType$;
exports.ConcurrentModificationException = ConcurrentModificationException;
exports.ConcurrentModificationException$ = ConcurrentModificationException$;
exports.ConfirmDevice$ = ConfirmDevice$;
exports.ConfirmDeviceCommand = ConfirmDeviceCommand;
exports.ConfirmDeviceRequest$ = ConfirmDeviceRequest$;
exports.ConfirmDeviceResponse$ = ConfirmDeviceResponse$;
exports.ConfirmForgotPassword$ = ConfirmForgotPassword$;
exports.ConfirmForgotPasswordCommand = ConfirmForgotPasswordCommand;
exports.ConfirmForgotPasswordRequest$ = ConfirmForgotPasswordRequest$;
exports.ConfirmForgotPasswordResponse$ = ConfirmForgotPasswordResponse$;
exports.ConfirmSignUp$ = ConfirmSignUp$;
exports.ConfirmSignUpCommand = ConfirmSignUpCommand;
exports.ConfirmSignUpRequest$ = ConfirmSignUpRequest$;
exports.ConfirmSignUpResponse$ = ConfirmSignUpResponse$;
exports.ContextDataType$ = ContextDataType$;
exports.CreateGroup$ = CreateGroup$;
exports.CreateGroupCommand = CreateGroupCommand;
exports.CreateGroupRequest$ = CreateGroupRequest$;
exports.CreateGroupResponse$ = CreateGroupResponse$;
exports.CreateIdentityProvider$ = CreateIdentityProvider$;
exports.CreateIdentityProviderCommand = CreateIdentityProviderCommand;
exports.CreateIdentityProviderRequest$ = CreateIdentityProviderRequest$;
exports.CreateIdentityProviderResponse$ = CreateIdentityProviderResponse$;
exports.CreateManagedLoginBranding$ = CreateManagedLoginBranding$;
exports.CreateManagedLoginBrandingCommand = CreateManagedLoginBrandingCommand;
exports.CreateManagedLoginBrandingRequest$ = CreateManagedLoginBrandingRequest$;
exports.CreateManagedLoginBrandingResponse$ = CreateManagedLoginBrandingResponse$;
exports.CreateResourceServer$ = CreateResourceServer$;
exports.CreateResourceServerCommand = CreateResourceServerCommand;
exports.CreateResourceServerRequest$ = CreateResourceServerRequest$;
exports.CreateResourceServerResponse$ = CreateResourceServerResponse$;
exports.CreateTerms$ = CreateTerms$;
exports.CreateTermsCommand = CreateTermsCommand;
exports.CreateTermsRequest$ = CreateTermsRequest$;
exports.CreateTermsResponse$ = CreateTermsResponse$;
exports.CreateUserImportJob$ = CreateUserImportJob$;
exports.CreateUserImportJobCommand = CreateUserImportJobCommand;
exports.CreateUserImportJobRequest$ = CreateUserImportJobRequest$;
exports.CreateUserImportJobResponse$ = CreateUserImportJobResponse$;
exports.CreateUserPool$ = CreateUserPool$;
exports.CreateUserPoolClient$ = CreateUserPoolClient$;
exports.CreateUserPoolClientCommand = CreateUserPoolClientCommand;
exports.CreateUserPoolClientRequest$ = CreateUserPoolClientRequest$;
exports.CreateUserPoolClientResponse$ = CreateUserPoolClientResponse$;
exports.CreateUserPoolCommand = CreateUserPoolCommand;
exports.CreateUserPoolDomain$ = CreateUserPoolDomain$;
exports.CreateUserPoolDomainCommand = CreateUserPoolDomainCommand;
exports.CreateUserPoolDomainRequest$ = CreateUserPoolDomainRequest$;
exports.CreateUserPoolDomainResponse$ = CreateUserPoolDomainResponse$;
exports.CreateUserPoolReplica$ = CreateUserPoolReplica$;
exports.CreateUserPoolReplicaCommand = CreateUserPoolReplicaCommand;
exports.CreateUserPoolReplicaRequest$ = CreateUserPoolReplicaRequest$;
exports.CreateUserPoolReplicaResponse$ = CreateUserPoolReplicaResponse$;
exports.CreateUserPoolRequest$ = CreateUserPoolRequest$;
exports.CreateUserPoolResponse$ = CreateUserPoolResponse$;
exports.CustomDomainConfigType$ = CustomDomainConfigType$;
exports.CustomEmailLambdaVersionConfigType$ = CustomEmailLambdaVersionConfigType$;
exports.CustomEmailSenderLambdaVersionType = CustomEmailSenderLambdaVersionType;
exports.CustomSMSLambdaVersionConfigType$ = CustomSMSLambdaVersionConfigType$;
exports.CustomSMSSenderLambdaVersionType = CustomSMSSenderLambdaVersionType;
exports.DefaultEmailOptionType = DefaultEmailOptionType;
exports.DeleteGroup$ = DeleteGroup$;
exports.DeleteGroupCommand = DeleteGroupCommand;
exports.DeleteGroupRequest$ = DeleteGroupRequest$;
exports.DeleteIdentityProvider$ = DeleteIdentityProvider$;
exports.DeleteIdentityProviderCommand = DeleteIdentityProviderCommand;
exports.DeleteIdentityProviderRequest$ = DeleteIdentityProviderRequest$;
exports.DeleteManagedLoginBranding$ = DeleteManagedLoginBranding$;
exports.DeleteManagedLoginBrandingCommand = DeleteManagedLoginBrandingCommand;
exports.DeleteManagedLoginBrandingRequest$ = DeleteManagedLoginBrandingRequest$;
exports.DeleteResourceServer$ = DeleteResourceServer$;
exports.DeleteResourceServerCommand = DeleteResourceServerCommand;
exports.DeleteResourceServerRequest$ = DeleteResourceServerRequest$;
exports.DeleteTerms$ = DeleteTerms$;
exports.DeleteTermsCommand = DeleteTermsCommand;
exports.DeleteTermsRequest$ = DeleteTermsRequest$;
exports.DeleteUser$ = DeleteUser$;
exports.DeleteUserAttributes$ = DeleteUserAttributes$;
exports.DeleteUserAttributesCommand = DeleteUserAttributesCommand;
exports.DeleteUserAttributesRequest$ = DeleteUserAttributesRequest$;
exports.DeleteUserAttributesResponse$ = DeleteUserAttributesResponse$;
exports.DeleteUserCommand = DeleteUserCommand;
exports.DeleteUserPool$ = DeleteUserPool$;
exports.DeleteUserPoolClient$ = DeleteUserPoolClient$;
exports.DeleteUserPoolClientCommand = DeleteUserPoolClientCommand;
exports.DeleteUserPoolClientRequest$ = DeleteUserPoolClientRequest$;
exports.DeleteUserPoolClientSecret$ = DeleteUserPoolClientSecret$;
exports.DeleteUserPoolClientSecretCommand = DeleteUserPoolClientSecretCommand;
exports.DeleteUserPoolClientSecretRequest$ = DeleteUserPoolClientSecretRequest$;
exports.DeleteUserPoolClientSecretResponse$ = DeleteUserPoolClientSecretResponse$;
exports.DeleteUserPoolCommand = DeleteUserPoolCommand;
exports.DeleteUserPoolDomain$ = DeleteUserPoolDomain$;
exports.DeleteUserPoolDomainCommand = DeleteUserPoolDomainCommand;
exports.DeleteUserPoolDomainRequest$ = DeleteUserPoolDomainRequest$;
exports.DeleteUserPoolDomainResponse$ = DeleteUserPoolDomainResponse$;
exports.DeleteUserPoolReplica$ = DeleteUserPoolReplica$;
exports.DeleteUserPoolReplicaCommand = DeleteUserPoolReplicaCommand;
exports.DeleteUserPoolReplicaRequest$ = DeleteUserPoolReplicaRequest$;
exports.DeleteUserPoolReplicaResponse$ = DeleteUserPoolReplicaResponse$;
exports.DeleteUserPoolRequest$ = DeleteUserPoolRequest$;
exports.DeleteUserRequest$ = DeleteUserRequest$;
exports.DeleteWebAuthnCredential$ = DeleteWebAuthnCredential$;
exports.DeleteWebAuthnCredentialCommand = DeleteWebAuthnCredentialCommand;
exports.DeleteWebAuthnCredentialRequest$ = DeleteWebAuthnCredentialRequest$;
exports.DeleteWebAuthnCredentialResponse$ = DeleteWebAuthnCredentialResponse$;
exports.DeletionProtectionType = DeletionProtectionType;
exports.DeliveryMediumType = DeliveryMediumType;
exports.DescribeIdentityProvider$ = DescribeIdentityProvider$;
exports.DescribeIdentityProviderCommand = DescribeIdentityProviderCommand;
exports.DescribeIdentityProviderRequest$ = DescribeIdentityProviderRequest$;
exports.DescribeIdentityProviderResponse$ = DescribeIdentityProviderResponse$;
exports.DescribeManagedLoginBranding$ = DescribeManagedLoginBranding$;
exports.DescribeManagedLoginBrandingByClient$ = DescribeManagedLoginBrandingByClient$;
exports.DescribeManagedLoginBrandingByClientCommand = DescribeManagedLoginBrandingByClientCommand;
exports.DescribeManagedLoginBrandingByClientRequest$ = DescribeManagedLoginBrandingByClientRequest$;
exports.DescribeManagedLoginBrandingByClientResponse$ = DescribeManagedLoginBrandingByClientResponse$;
exports.DescribeManagedLoginBrandingCommand = DescribeManagedLoginBrandingCommand;
exports.DescribeManagedLoginBrandingRequest$ = DescribeManagedLoginBrandingRequest$;
exports.DescribeManagedLoginBrandingResponse$ = DescribeManagedLoginBrandingResponse$;
exports.DescribeResourceServer$ = DescribeResourceServer$;
exports.DescribeResourceServerCommand = DescribeResourceServerCommand;
exports.DescribeResourceServerRequest$ = DescribeResourceServerRequest$;
exports.DescribeResourceServerResponse$ = DescribeResourceServerResponse$;
exports.DescribeRiskConfiguration$ = DescribeRiskConfiguration$;
exports.DescribeRiskConfigurationCommand = DescribeRiskConfigurationCommand;
exports.DescribeRiskConfigurationRequest$ = DescribeRiskConfigurationRequest$;
exports.DescribeRiskConfigurationResponse$ = DescribeRiskConfigurationResponse$;
exports.DescribeTerms$ = DescribeTerms$;
exports.DescribeTermsByClient$ = DescribeTermsByClient$;
exports.DescribeTermsByClientCommand = DescribeTermsByClientCommand;
exports.DescribeTermsByClientRequest$ = DescribeTermsByClientRequest$;
exports.DescribeTermsByClientResponse$ = DescribeTermsByClientResponse$;
exports.DescribeTermsCommand = DescribeTermsCommand;
exports.DescribeTermsRequest$ = DescribeTermsRequest$;
exports.DescribeTermsResponse$ = DescribeTermsResponse$;
exports.DescribeUserImportJob$ = DescribeUserImportJob$;
exports.DescribeUserImportJobCommand = DescribeUserImportJobCommand;
exports.DescribeUserImportJobRequest$ = DescribeUserImportJobRequest$;
exports.DescribeUserImportJobResponse$ = DescribeUserImportJobResponse$;
exports.DescribeUserPool$ = DescribeUserPool$;
exports.DescribeUserPoolClient$ = DescribeUserPoolClient$;
exports.DescribeUserPoolClientCommand = DescribeUserPoolClientCommand;
exports.DescribeUserPoolClientRequest$ = DescribeUserPoolClientRequest$;
exports.DescribeUserPoolClientResponse$ = DescribeUserPoolClientResponse$;
exports.DescribeUserPoolCommand = DescribeUserPoolCommand;
exports.DescribeUserPoolDomain$ = DescribeUserPoolDomain$;
exports.DescribeUserPoolDomainCommand = DescribeUserPoolDomainCommand;
exports.DescribeUserPoolDomainRequest$ = DescribeUserPoolDomainRequest$;
exports.DescribeUserPoolDomainResponse$ = DescribeUserPoolDomainResponse$;
exports.DescribeUserPoolRequest$ = DescribeUserPoolRequest$;
exports.DescribeUserPoolResponse$ = DescribeUserPoolResponse$;
exports.DeviceConfigurationType$ = DeviceConfigurationType$;
exports.DeviceKeyExistsException = DeviceKeyExistsException;
exports.DeviceKeyExistsException$ = DeviceKeyExistsException$;
exports.DeviceRememberedStatusType = DeviceRememberedStatusType;
exports.DeviceSecretVerifierConfigType$ = DeviceSecretVerifierConfigType$;
exports.DeviceType$ = DeviceType$;
exports.DomainDescriptionType$ = DomainDescriptionType$;
exports.DomainStatusType = DomainStatusType;
exports.DuplicateProviderException = DuplicateProviderException;
exports.DuplicateProviderException$ = DuplicateProviderException$;
exports.EmailConfigurationType$ = EmailConfigurationType$;
exports.EmailMfaConfigType$ = EmailMfaConfigType$;
exports.EmailMfaSettingsType$ = EmailMfaSettingsType$;
exports.EmailSendingAccountType = EmailSendingAccountType;
exports.EnableSoftwareTokenMFAException = EnableSoftwareTokenMFAException;
exports.EnableSoftwareTokenMFAException$ = EnableSoftwareTokenMFAException$;
exports.EncryptionKeyType = EncryptionKeyType;
exports.EumsSmsConfigurationType$ = EumsSmsConfigurationType$;
exports.EventContextDataType$ = EventContextDataType$;
exports.EventFeedbackType$ = EventFeedbackType$;
exports.EventFilterType = EventFilterType;
exports.EventResponseType = EventResponseType;
exports.EventRiskType$ = EventRiskType$;
exports.EventSourceName = EventSourceName;
exports.EventType = EventType;
exports.ExpiredCodeException = ExpiredCodeException;
exports.ExpiredCodeException$ = ExpiredCodeException$;
exports.ExplicitAuthFlowsType = ExplicitAuthFlowsType;
exports.FailoverType$ = FailoverType$;
exports.FeatureType = FeatureType;
exports.FeatureUnavailableInTierException = FeatureUnavailableInTierException;
exports.FeatureUnavailableInTierException$ = FeatureUnavailableInTierException$;
exports.FeedbackValueType = FeedbackValueType;
exports.FirehoseConfigurationType$ = FirehoseConfigurationType$;
exports.ForbiddenException = ForbiddenException;
exports.ForbiddenException$ = ForbiddenException$;
exports.ForgetDevice$ = ForgetDevice$;
exports.ForgetDeviceCommand = ForgetDeviceCommand;
exports.ForgetDeviceRequest$ = ForgetDeviceRequest$;
exports.ForgotPassword$ = ForgotPassword$;
exports.ForgotPasswordCommand = ForgotPasswordCommand;
exports.ForgotPasswordRequest$ = ForgotPasswordRequest$;
exports.ForgotPasswordResponse$ = ForgotPasswordResponse$;
exports.GetCSVHeader$ = GetCSVHeader$;
exports.GetCSVHeaderCommand = GetCSVHeaderCommand;
exports.GetCSVHeaderRequest$ = GetCSVHeaderRequest$;
exports.GetCSVHeaderResponse$ = GetCSVHeaderResponse$;
exports.GetClientToken$ = GetClientToken$;
exports.GetClientTokenCommand = GetClientTokenCommand;
exports.GetClientTokenRequest$ = GetClientTokenRequest$;
exports.GetClientTokenResponse$ = GetClientTokenResponse$;
exports.GetDevice$ = GetDevice$;
exports.GetDeviceCommand = GetDeviceCommand;
exports.GetDeviceRequest$ = GetDeviceRequest$;
exports.GetDeviceResponse$ = GetDeviceResponse$;
exports.GetGroup$ = GetGroup$;
exports.GetGroupCommand = GetGroupCommand;
exports.GetGroupRequest$ = GetGroupRequest$;
exports.GetGroupResponse$ = GetGroupResponse$;
exports.GetIdentityProviderByIdentifier$ = GetIdentityProviderByIdentifier$;
exports.GetIdentityProviderByIdentifierCommand = GetIdentityProviderByIdentifierCommand;
exports.GetIdentityProviderByIdentifierRequest$ = GetIdentityProviderByIdentifierRequest$;
exports.GetIdentityProviderByIdentifierResponse$ = GetIdentityProviderByIdentifierResponse$;
exports.GetLogDeliveryConfiguration$ = GetLogDeliveryConfiguration$;
exports.GetLogDeliveryConfigurationCommand = GetLogDeliveryConfigurationCommand;
exports.GetLogDeliveryConfigurationRequest$ = GetLogDeliveryConfigurationRequest$;
exports.GetLogDeliveryConfigurationResponse$ = GetLogDeliveryConfigurationResponse$;
exports.GetProvisionedLimit$ = GetProvisionedLimit$;
exports.GetProvisionedLimitCommand = GetProvisionedLimitCommand;
exports.GetProvisionedLimitRequest$ = GetProvisionedLimitRequest$;
exports.GetProvisionedLimitResponse$ = GetProvisionedLimitResponse$;
exports.GetSigningCertificate$ = GetSigningCertificate$;
exports.GetSigningCertificateCommand = GetSigningCertificateCommand;
exports.GetSigningCertificateRequest$ = GetSigningCertificateRequest$;
exports.GetSigningCertificateResponse$ = GetSigningCertificateResponse$;
exports.GetTokensFromRefreshToken$ = GetTokensFromRefreshToken$;
exports.GetTokensFromRefreshTokenCommand = GetTokensFromRefreshTokenCommand;
exports.GetTokensFromRefreshTokenRequest$ = GetTokensFromRefreshTokenRequest$;
exports.GetTokensFromRefreshTokenResponse$ = GetTokensFromRefreshTokenResponse$;
exports.GetUICustomization$ = GetUICustomization$;
exports.GetUICustomizationCommand = GetUICustomizationCommand;
exports.GetUICustomizationRequest$ = GetUICustomizationRequest$;
exports.GetUICustomizationResponse$ = GetUICustomizationResponse$;
exports.GetUser$ = GetUser$;
exports.GetUserAttributeVerificationCode$ = GetUserAttributeVerificationCode$;
exports.GetUserAttributeVerificationCodeCommand = GetUserAttributeVerificationCodeCommand;
exports.GetUserAttributeVerificationCodeRequest$ = GetUserAttributeVerificationCodeRequest$;
exports.GetUserAttributeVerificationCodeResponse$ = GetUserAttributeVerificationCodeResponse$;
exports.GetUserAuthFactors$ = GetUserAuthFactors$;
exports.GetUserAuthFactorsCommand = GetUserAuthFactorsCommand;
exports.GetUserAuthFactorsRequest$ = GetUserAuthFactorsRequest$;
exports.GetUserAuthFactorsResponse$ = GetUserAuthFactorsResponse$;
exports.GetUserCommand = GetUserCommand;
exports.GetUserPoolMfaConfig$ = GetUserPoolMfaConfig$;
exports.GetUserPoolMfaConfigCommand = GetUserPoolMfaConfigCommand;
exports.GetUserPoolMfaConfigRequest$ = GetUserPoolMfaConfigRequest$;
exports.GetUserPoolMfaConfigResponse$ = GetUserPoolMfaConfigResponse$;
exports.GetUserRequest$ = GetUserRequest$;
exports.GetUserResponse$ = GetUserResponse$;
exports.GlobalSignOut$ = GlobalSignOut$;
exports.GlobalSignOutCommand = GlobalSignOutCommand;
exports.GlobalSignOutRequest$ = GlobalSignOutRequest$;
exports.GlobalSignOutResponse$ = GlobalSignOutResponse$;
exports.GroupExistsException = GroupExistsException;
exports.GroupExistsException$ = GroupExistsException$;
exports.GroupType$ = GroupType$;
exports.HttpHeader$ = HttpHeader$;
exports.IdentityProviderType$ = IdentityProviderType$;
exports.IdentityProviderTypeType = IdentityProviderTypeType;
exports.InboundFederationLambdaType$ = InboundFederationLambdaType$;
exports.InboundFederationLambdaVersionType = InboundFederationLambdaVersionType;
exports.InitiateAuth$ = InitiateAuth$;
exports.InitiateAuthCommand = InitiateAuthCommand;
exports.InitiateAuthRequest$ = InitiateAuthRequest$;
exports.InitiateAuthResponse$ = InitiateAuthResponse$;
exports.InternalErrorException = InternalErrorException;
exports.InternalErrorException$ = InternalErrorException$;
exports.InternalServerException = InternalServerException;
exports.InternalServerException$ = InternalServerException$;
exports.InvalidEmailRoleAccessPolicyException = InvalidEmailRoleAccessPolicyException;
exports.InvalidEmailRoleAccessPolicyException$ = InvalidEmailRoleAccessPolicyException$;
exports.InvalidLambdaResponseException = InvalidLambdaResponseException;
exports.InvalidLambdaResponseException$ = InvalidLambdaResponseException$;
exports.InvalidOAuthFlowException = InvalidOAuthFlowException;
exports.InvalidOAuthFlowException$ = InvalidOAuthFlowException$;
exports.InvalidParameterException = InvalidParameterException;
exports.InvalidParameterException$ = InvalidParameterException$;
exports.InvalidPasswordException = InvalidPasswordException;
exports.InvalidPasswordException$ = InvalidPasswordException$;
exports.InvalidSmsRoleAccessPolicyException = InvalidSmsRoleAccessPolicyException;
exports.InvalidSmsRoleAccessPolicyException$ = InvalidSmsRoleAccessPolicyException$;
exports.InvalidSmsRoleTrustRelationshipException = InvalidSmsRoleTrustRelationshipException;
exports.InvalidSmsRoleTrustRelationshipException$ = InvalidSmsRoleTrustRelationshipException$;
exports.InvalidUserPoolConfigurationException = InvalidUserPoolConfigurationException;
exports.InvalidUserPoolConfigurationException$ = InvalidUserPoolConfigurationException$;
exports.IssuerConfigurationType$ = IssuerConfigurationType$;
exports.IssuerType = IssuerType;
exports.KeyConfigurationType$ = KeyConfigurationType$;
exports.LambdaConfigType$ = LambdaConfigType$;
exports.LimitClass = LimitClass;
exports.LimitDefinitionType$ = LimitDefinitionType$;
exports.LimitExceededException = LimitExceededException;
exports.LimitExceededException$ = LimitExceededException$;
exports.LimitType$ = LimitType$;
exports.ListDevices$ = ListDevices$;
exports.ListDevicesCommand = ListDevicesCommand;
exports.ListDevicesRequest$ = ListDevicesRequest$;
exports.ListDevicesResponse$ = ListDevicesResponse$;
exports.ListGroups$ = ListGroups$;
exports.ListGroupsCommand = ListGroupsCommand;
exports.ListGroupsRequest$ = ListGroupsRequest$;
exports.ListGroupsResponse$ = ListGroupsResponse$;
exports.ListIdentityProviders$ = ListIdentityProviders$;
exports.ListIdentityProvidersCommand = ListIdentityProvidersCommand;
exports.ListIdentityProvidersRequest$ = ListIdentityProvidersRequest$;
exports.ListIdentityProvidersResponse$ = ListIdentityProvidersResponse$;
exports.ListResourceServers$ = ListResourceServers$;
exports.ListResourceServersCommand = ListResourceServersCommand;
exports.ListResourceServersRequest$ = ListResourceServersRequest$;
exports.ListResourceServersResponse$ = ListResourceServersResponse$;
exports.ListTagsForResource$ = ListTagsForResource$;
exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
exports.ListTagsForResourceRequest$ = ListTagsForResourceRequest$;
exports.ListTagsForResourceResponse$ = ListTagsForResourceResponse$;
exports.ListTerms$ = ListTerms$;
exports.ListTermsCommand = ListTermsCommand;
exports.ListTermsRequest$ = ListTermsRequest$;
exports.ListTermsResponse$ = ListTermsResponse$;
exports.ListUserImportJobs$ = ListUserImportJobs$;
exports.ListUserImportJobsCommand = ListUserImportJobsCommand;
exports.ListUserImportJobsRequest$ = ListUserImportJobsRequest$;
exports.ListUserImportJobsResponse$ = ListUserImportJobsResponse$;
exports.ListUserPoolClientSecrets$ = ListUserPoolClientSecrets$;
exports.ListUserPoolClientSecretsCommand = ListUserPoolClientSecretsCommand;
exports.ListUserPoolClientSecretsRequest$ = ListUserPoolClientSecretsRequest$;
exports.ListUserPoolClientSecretsResponse$ = ListUserPoolClientSecretsResponse$;
exports.ListUserPoolClients$ = ListUserPoolClients$;
exports.ListUserPoolClientsCommand = ListUserPoolClientsCommand;
exports.ListUserPoolClientsRequest$ = ListUserPoolClientsRequest$;
exports.ListUserPoolClientsResponse$ = ListUserPoolClientsResponse$;
exports.ListUserPoolReplicas$ = ListUserPoolReplicas$;
exports.ListUserPoolReplicasCommand = ListUserPoolReplicasCommand;
exports.ListUserPoolReplicasRequest$ = ListUserPoolReplicasRequest$;
exports.ListUserPoolReplicasResponse$ = ListUserPoolReplicasResponse$;
exports.ListUserPools$ = ListUserPools$;
exports.ListUserPoolsCommand = ListUserPoolsCommand;
exports.ListUserPoolsRequest$ = ListUserPoolsRequest$;
exports.ListUserPoolsResponse$ = ListUserPoolsResponse$;
exports.ListUsers$ = ListUsers$;
exports.ListUsersCommand = ListUsersCommand;
exports.ListUsersInGroup$ = ListUsersInGroup$;
exports.ListUsersInGroupCommand = ListUsersInGroupCommand;
exports.ListUsersInGroupRequest$ = ListUsersInGroupRequest$;
exports.ListUsersInGroupResponse$ = ListUsersInGroupResponse$;
exports.ListUsersRequest$ = ListUsersRequest$;
exports.ListUsersResponse$ = ListUsersResponse$;
exports.ListWebAuthnCredentials$ = ListWebAuthnCredentials$;
exports.ListWebAuthnCredentialsCommand = ListWebAuthnCredentialsCommand;
exports.ListWebAuthnCredentialsRequest$ = ListWebAuthnCredentialsRequest$;
exports.ListWebAuthnCredentialsResponse$ = ListWebAuthnCredentialsResponse$;
exports.LogConfigurationType$ = LogConfigurationType$;
exports.LogDeliveryConfigurationType$ = LogDeliveryConfigurationType$;
exports.LogLevel = LogLevel;
exports.MFAMethodNotFoundException = MFAMethodNotFoundException;
exports.MFAMethodNotFoundException$ = MFAMethodNotFoundException$;
exports.MFAOptionType$ = MFAOptionType$;
exports.ManagedLoginBrandingExistsException = ManagedLoginBrandingExistsException;
exports.ManagedLoginBrandingExistsException$ = ManagedLoginBrandingExistsException$;
exports.ManagedLoginBrandingType$ = ManagedLoginBrandingType$;
exports.MessageActionType = MessageActionType;
exports.MessageTemplateType$ = MessageTemplateType$;
exports.NewDeviceMetadataType$ = NewDeviceMetadataType$;
exports.NotAuthorizedException = NotAuthorizedException;
exports.NotAuthorizedException$ = NotAuthorizedException$;
exports.NotifyConfigurationType$ = NotifyConfigurationType$;
exports.NotifyEmailType$ = NotifyEmailType$;
exports.NumberAttributeConstraintsType$ = NumberAttributeConstraintsType$;
exports.OAuthFlowType = OAuthFlowType;
exports.OperationNotEnabledException = OperationNotEnabledException;
exports.OperationNotEnabledException$ = OperationNotEnabledException$;
exports.PasswordHashingAlgorithmType = PasswordHashingAlgorithmType;
exports.PasswordHistoryPolicyViolationException = PasswordHistoryPolicyViolationException;
exports.PasswordHistoryPolicyViolationException$ = PasswordHistoryPolicyViolationException$;
exports.PasswordPolicyType$ = PasswordPolicyType$;
exports.PasswordResetRequiredException = PasswordResetRequiredException;
exports.PasswordResetRequiredException$ = PasswordResetRequiredException$;
exports.PreTokenGenerationLambdaVersionType = PreTokenGenerationLambdaVersionType;
exports.PreTokenGenerationVersionConfigType$ = PreTokenGenerationVersionConfigType$;
exports.PreconditionNotMetException = PreconditionNotMetException;
exports.PreconditionNotMetException$ = PreconditionNotMetException$;
exports.PreventUserExistenceErrorTypes = PreventUserExistenceErrorTypes;
exports.ProviderDescription$ = ProviderDescription$;
exports.ProviderUserIdentifierType$ = ProviderUserIdentifierType$;
exports.RecoveryOptionNameType = RecoveryOptionNameType;
exports.RecoveryOptionType$ = RecoveryOptionType$;
exports.RefreshTokenReuseException = RefreshTokenReuseException;
exports.RefreshTokenReuseException$ = RefreshTokenReuseException$;
exports.RefreshTokenRotationType$ = RefreshTokenRotationType$;
exports.ReplicaRoleType = ReplicaRoleType;
exports.ReplicaStatusType = ReplicaStatusType;
exports.ResendConfirmationCode$ = ResendConfirmationCode$;
exports.ResendConfirmationCodeCommand = ResendConfirmationCodeCommand;
exports.ResendConfirmationCodeRequest$ = ResendConfirmationCodeRequest$;
exports.ResendConfirmationCodeResponse$ = ResendConfirmationCodeResponse$;
exports.ResourceNotFoundException = ResourceNotFoundException;
exports.ResourceNotFoundException$ = ResourceNotFoundException$;
exports.ResourceServerScopeType$ = ResourceServerScopeType$;
exports.ResourceServerType$ = ResourceServerType$;
exports.RespondToAuthChallenge$ = RespondToAuthChallenge$;
exports.RespondToAuthChallengeCommand = RespondToAuthChallengeCommand;
exports.RespondToAuthChallengeRequest$ = RespondToAuthChallengeRequest$;
exports.RespondToAuthChallengeResponse$ = RespondToAuthChallengeResponse$;
exports.RevokeToken$ = RevokeToken$;
exports.RevokeTokenCommand = RevokeTokenCommand;
exports.RevokeTokenRequest$ = RevokeTokenRequest$;
exports.RevokeTokenResponse$ = RevokeTokenResponse$;
exports.RiskConfigurationType$ = RiskConfigurationType$;
exports.RiskDecisionType = RiskDecisionType;
exports.RiskExceptionConfigurationType$ = RiskExceptionConfigurationType$;
exports.RiskLevelType = RiskLevelType;
exports.RoutingType$ = RoutingType$;
exports.S3ConfigurationType$ = S3ConfigurationType$;
exports.SMSMfaSettingsType$ = SMSMfaSettingsType$;
exports.SchemaAttributeType$ = SchemaAttributeType$;
exports.ScopeDoesNotExistException = ScopeDoesNotExistException;
exports.ScopeDoesNotExistException$ = ScopeDoesNotExistException$;
exports.SecurityPolicyType = SecurityPolicyType;
exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
exports.ServiceQuotaExceededException$ = ServiceQuotaExceededException$;
exports.SetLogDeliveryConfiguration$ = SetLogDeliveryConfiguration$;
exports.SetLogDeliveryConfigurationCommand = SetLogDeliveryConfigurationCommand;
exports.SetLogDeliveryConfigurationRequest$ = SetLogDeliveryConfigurationRequest$;
exports.SetLogDeliveryConfigurationResponse$ = SetLogDeliveryConfigurationResponse$;
exports.SetRiskConfiguration$ = SetRiskConfiguration$;
exports.SetRiskConfigurationCommand = SetRiskConfigurationCommand;
exports.SetRiskConfigurationRequest$ = SetRiskConfigurationRequest$;
exports.SetRiskConfigurationResponse$ = SetRiskConfigurationResponse$;
exports.SetUICustomization$ = SetUICustomization$;
exports.SetUICustomizationCommand = SetUICustomizationCommand;
exports.SetUICustomizationRequest$ = SetUICustomizationRequest$;
exports.SetUICustomizationResponse$ = SetUICustomizationResponse$;
exports.SetUserMFAPreference$ = SetUserMFAPreference$;
exports.SetUserMFAPreferenceCommand = SetUserMFAPreferenceCommand;
exports.SetUserMFAPreferenceRequest$ = SetUserMFAPreferenceRequest$;
exports.SetUserMFAPreferenceResponse$ = SetUserMFAPreferenceResponse$;
exports.SetUserPoolMfaConfig$ = SetUserPoolMfaConfig$;
exports.SetUserPoolMfaConfigCommand = SetUserPoolMfaConfigCommand;
exports.SetUserPoolMfaConfigRequest$ = SetUserPoolMfaConfigRequest$;
exports.SetUserPoolMfaConfigResponse$ = SetUserPoolMfaConfigResponse$;
exports.SetUserSettings$ = SetUserSettings$;
exports.SetUserSettingsCommand = SetUserSettingsCommand;
exports.SetUserSettingsRequest$ = SetUserSettingsRequest$;
exports.SetUserSettingsResponse$ = SetUserSettingsResponse$;
exports.SignInPolicyType$ = SignInPolicyType$;
exports.SignUp$ = SignUp$;
exports.SignUpCommand = SignUpCommand;
exports.SignUpRequest$ = SignUpRequest$;
exports.SignUpResponse$ = SignUpResponse$;
exports.SmsConfigurationType$ = SmsConfigurationType$;
exports.SmsMfaConfigType$ = SmsMfaConfigType$;
exports.SoftwareTokenMFANotFoundException = SoftwareTokenMFANotFoundException;
exports.SoftwareTokenMFANotFoundException$ = SoftwareTokenMFANotFoundException$;
exports.SoftwareTokenMfaConfigType$ = SoftwareTokenMfaConfigType$;
exports.SoftwareTokenMfaSettingsType$ = SoftwareTokenMfaSettingsType$;
exports.StartUserImportJob$ = StartUserImportJob$;
exports.StartUserImportJobCommand = StartUserImportJobCommand;
exports.StartUserImportJobRequest$ = StartUserImportJobRequest$;
exports.StartUserImportJobResponse$ = StartUserImportJobResponse$;
exports.StartWebAuthnRegistration$ = StartWebAuthnRegistration$;
exports.StartWebAuthnRegistrationCommand = StartWebAuthnRegistrationCommand;
exports.StartWebAuthnRegistrationRequest$ = StartWebAuthnRegistrationRequest$;
exports.StartWebAuthnRegistrationResponse$ = StartWebAuthnRegistrationResponse$;
exports.StatusType = StatusType;
exports.StopUserImportJob$ = StopUserImportJob$;
exports.StopUserImportJobCommand = StopUserImportJobCommand;
exports.StopUserImportJobRequest$ = StopUserImportJobRequest$;
exports.StopUserImportJobResponse$ = StopUserImportJobResponse$;
exports.StringAttributeConstraintsType$ = StringAttributeConstraintsType$;
exports.TagResource$ = TagResource$;
exports.TagResourceCommand = TagResourceCommand;
exports.TagResourceRequest$ = TagResourceRequest$;
exports.TagResourceResponse$ = TagResourceResponse$;
exports.TermsDescriptionType$ = TermsDescriptionType$;
exports.TermsEnforcementType = TermsEnforcementType;
exports.TermsExistsException = TermsExistsException;
exports.TermsExistsException$ = TermsExistsException$;
exports.TermsSourceType = TermsSourceType;
exports.TermsType$ = TermsType$;
exports.TierChangeNotAllowedException = TierChangeNotAllowedException;
exports.TierChangeNotAllowedException$ = TierChangeNotAllowedException$;
exports.TimeUnitsType = TimeUnitsType;
exports.TokenValidityUnitsType$ = TokenValidityUnitsType$;
exports.TooManyFailedAttemptsException = TooManyFailedAttemptsException;
exports.TooManyFailedAttemptsException$ = TooManyFailedAttemptsException$;
exports.TooManyRequestsException = TooManyRequestsException;
exports.TooManyRequestsException$ = TooManyRequestsException$;
exports.UICustomizationType$ = UICustomizationType$;
exports.UnauthorizedException = UnauthorizedException;
exports.UnauthorizedException$ = UnauthorizedException$;
exports.UnexpectedLambdaException = UnexpectedLambdaException;
exports.UnexpectedLambdaException$ = UnexpectedLambdaException$;
exports.UnsupportedIdentityProviderException = UnsupportedIdentityProviderException;
exports.UnsupportedIdentityProviderException$ = UnsupportedIdentityProviderException$;
exports.UnsupportedOperationException = UnsupportedOperationException;
exports.UnsupportedOperationException$ = UnsupportedOperationException$;
exports.UnsupportedTokenTypeException = UnsupportedTokenTypeException;
exports.UnsupportedTokenTypeException$ = UnsupportedTokenTypeException$;
exports.UnsupportedUserStateException = UnsupportedUserStateException;
exports.UnsupportedUserStateException$ = UnsupportedUserStateException$;
exports.UntagResource$ = UntagResource$;
exports.UntagResourceCommand = UntagResourceCommand;
exports.UntagResourceRequest$ = UntagResourceRequest$;
exports.UntagResourceResponse$ = UntagResourceResponse$;
exports.UpdateAuthEventFeedback$ = UpdateAuthEventFeedback$;
exports.UpdateAuthEventFeedbackCommand = UpdateAuthEventFeedbackCommand;
exports.UpdateAuthEventFeedbackRequest$ = UpdateAuthEventFeedbackRequest$;
exports.UpdateAuthEventFeedbackResponse$ = UpdateAuthEventFeedbackResponse$;
exports.UpdateDeviceStatus$ = UpdateDeviceStatus$;
exports.UpdateDeviceStatusCommand = UpdateDeviceStatusCommand;
exports.UpdateDeviceStatusRequest$ = UpdateDeviceStatusRequest$;
exports.UpdateDeviceStatusResponse$ = UpdateDeviceStatusResponse$;
exports.UpdateGroup$ = UpdateGroup$;
exports.UpdateGroupCommand = UpdateGroupCommand;
exports.UpdateGroupRequest$ = UpdateGroupRequest$;
exports.UpdateGroupResponse$ = UpdateGroupResponse$;
exports.UpdateIdentityProvider$ = UpdateIdentityProvider$;
exports.UpdateIdentityProviderCommand = UpdateIdentityProviderCommand;
exports.UpdateIdentityProviderRequest$ = UpdateIdentityProviderRequest$;
exports.UpdateIdentityProviderResponse$ = UpdateIdentityProviderResponse$;
exports.UpdateManagedLoginBranding$ = UpdateManagedLoginBranding$;
exports.UpdateManagedLoginBrandingCommand = UpdateManagedLoginBrandingCommand;
exports.UpdateManagedLoginBrandingRequest$ = UpdateManagedLoginBrandingRequest$;
exports.UpdateManagedLoginBrandingResponse$ = UpdateManagedLoginBrandingResponse$;
exports.UpdateProvisionedLimit$ = UpdateProvisionedLimit$;
exports.UpdateProvisionedLimitCommand = UpdateProvisionedLimitCommand;
exports.UpdateProvisionedLimitRequest$ = UpdateProvisionedLimitRequest$;
exports.UpdateProvisionedLimitResponse$ = UpdateProvisionedLimitResponse$;
exports.UpdateReplicaStatusType = UpdateReplicaStatusType;
exports.UpdateResourceServer$ = UpdateResourceServer$;
exports.UpdateResourceServerCommand = UpdateResourceServerCommand;
exports.UpdateResourceServerRequest$ = UpdateResourceServerRequest$;
exports.UpdateResourceServerResponse$ = UpdateResourceServerResponse$;
exports.UpdateTerms$ = UpdateTerms$;
exports.UpdateTermsCommand = UpdateTermsCommand;
exports.UpdateTermsRequest$ = UpdateTermsRequest$;
exports.UpdateTermsResponse$ = UpdateTermsResponse$;
exports.UpdateUserAttributes$ = UpdateUserAttributes$;
exports.UpdateUserAttributesCommand = UpdateUserAttributesCommand;
exports.UpdateUserAttributesRequest$ = UpdateUserAttributesRequest$;
exports.UpdateUserAttributesResponse$ = UpdateUserAttributesResponse$;
exports.UpdateUserPool$ = UpdateUserPool$;
exports.UpdateUserPoolClient$ = UpdateUserPoolClient$;
exports.UpdateUserPoolClientCommand = UpdateUserPoolClientCommand;
exports.UpdateUserPoolClientRequest$ = UpdateUserPoolClientRequest$;
exports.UpdateUserPoolClientResponse$ = UpdateUserPoolClientResponse$;
exports.UpdateUserPoolCommand = UpdateUserPoolCommand;
exports.UpdateUserPoolDomain$ = UpdateUserPoolDomain$;
exports.UpdateUserPoolDomainCommand = UpdateUserPoolDomainCommand;
exports.UpdateUserPoolDomainRequest$ = UpdateUserPoolDomainRequest$;
exports.UpdateUserPoolDomainResponse$ = UpdateUserPoolDomainResponse$;
exports.UpdateUserPoolReplica$ = UpdateUserPoolReplica$;
exports.UpdateUserPoolReplicaCommand = UpdateUserPoolReplicaCommand;
exports.UpdateUserPoolReplicaRequest$ = UpdateUserPoolReplicaRequest$;
exports.UpdateUserPoolReplicaResponse$ = UpdateUserPoolReplicaResponse$;
exports.UpdateUserPoolRequest$ = UpdateUserPoolRequest$;
exports.UpdateUserPoolResponse$ = UpdateUserPoolResponse$;
exports.UserAttributeUpdateSettingsType$ = UserAttributeUpdateSettingsType$;
exports.UserContextDataType$ = UserContextDataType$;
exports.UserImportInProgressException = UserImportInProgressException;
exports.UserImportInProgressException$ = UserImportInProgressException$;
exports.UserImportJobStatusType = UserImportJobStatusType;
exports.UserImportJobType$ = UserImportJobType$;
exports.UserLambdaValidationException = UserLambdaValidationException;
exports.UserLambdaValidationException$ = UserLambdaValidationException$;
exports.UserNotConfirmedException = UserNotConfirmedException;
exports.UserNotConfirmedException$ = UserNotConfirmedException$;
exports.UserNotFoundException = UserNotFoundException;
exports.UserNotFoundException$ = UserNotFoundException$;
exports.UserPoolAddOnNotEnabledException = UserPoolAddOnNotEnabledException;
exports.UserPoolAddOnNotEnabledException$ = UserPoolAddOnNotEnabledException$;
exports.UserPoolAddOnsType$ = UserPoolAddOnsType$;
exports.UserPoolClientDescription$ = UserPoolClientDescription$;
exports.UserPoolClientType$ = UserPoolClientType$;
exports.UserPoolDescriptionType$ = UserPoolDescriptionType$;
exports.UserPoolMfaType = UserPoolMfaType;
exports.UserPoolPolicyType$ = UserPoolPolicyType$;
exports.UserPoolReplicaType$ = UserPoolReplicaType$;
exports.UserPoolTaggingException = UserPoolTaggingException;
exports.UserPoolTaggingException$ = UserPoolTaggingException$;
exports.UserPoolTierType = UserPoolTierType;
exports.UserPoolType$ = UserPoolType$;
exports.UserStatusType = UserStatusType;
exports.UserType$ = UserType$;
exports.UserVerificationType = UserVerificationType;
exports.UsernameAttributeType = UsernameAttributeType;
exports.UsernameConfigurationType$ = UsernameConfigurationType$;
exports.UsernameExistsException = UsernameExistsException;
exports.UsernameExistsException$ = UsernameExistsException$;
exports.VerificationMessageTemplateType$ = VerificationMessageTemplateType$;
exports.VerifiedAttributeType = VerifiedAttributeType;
exports.VerifySoftwareToken$ = VerifySoftwareToken$;
exports.VerifySoftwareTokenCommand = VerifySoftwareTokenCommand;
exports.VerifySoftwareTokenRequest$ = VerifySoftwareTokenRequest$;
exports.VerifySoftwareTokenResponse$ = VerifySoftwareTokenResponse$;
exports.VerifySoftwareTokenResponseType = VerifySoftwareTokenResponseType;
exports.VerifyUserAttribute$ = VerifyUserAttribute$;
exports.VerifyUserAttributeCommand = VerifyUserAttributeCommand;
exports.VerifyUserAttributeRequest$ = VerifyUserAttributeRequest$;
exports.VerifyUserAttributeResponse$ = VerifyUserAttributeResponse$;
exports.WebAuthnChallengeNotFoundException = WebAuthnChallengeNotFoundException;
exports.WebAuthnChallengeNotFoundException$ = WebAuthnChallengeNotFoundException$;
exports.WebAuthnClientMismatchException = WebAuthnClientMismatchException;
exports.WebAuthnClientMismatchException$ = WebAuthnClientMismatchException$;
exports.WebAuthnConfigurationMissingException = WebAuthnConfigurationMissingException;
exports.WebAuthnConfigurationMissingException$ = WebAuthnConfigurationMissingException$;
exports.WebAuthnConfigurationType$ = WebAuthnConfigurationType$;
exports.WebAuthnCredentialDescription$ = WebAuthnCredentialDescription$;
exports.WebAuthnCredentialNotSupportedException = WebAuthnCredentialNotSupportedException;
exports.WebAuthnCredentialNotSupportedException$ = WebAuthnCredentialNotSupportedException$;
exports.WebAuthnFactorConfigurationType = WebAuthnFactorConfigurationType;
exports.WebAuthnMfaSettingsType$ = WebAuthnMfaSettingsType$;
exports.WebAuthnNotEnabledException = WebAuthnNotEnabledException;
exports.WebAuthnNotEnabledException$ = WebAuthnNotEnabledException$;
exports.WebAuthnOriginNotAllowedException = WebAuthnOriginNotAllowedException;
exports.WebAuthnOriginNotAllowedException$ = WebAuthnOriginNotAllowedException$;
exports.WebAuthnRelyingPartyMismatchException = WebAuthnRelyingPartyMismatchException;
exports.WebAuthnRelyingPartyMismatchException$ = WebAuthnRelyingPartyMismatchException$;
exports.errorTypeRegistries = errorTypeRegistries;
exports.paginateAdminListGroupsForUser = paginateAdminListGroupsForUser;
exports.paginateAdminListUserAuthEvents = paginateAdminListUserAuthEvents;
exports.paginateListGroups = paginateListGroups;
exports.paginateListIdentityProviders = paginateListIdentityProviders;
exports.paginateListResourceServers = paginateListResourceServers;
exports.paginateListUserPoolClients = paginateListUserPoolClients;
exports.paginateListUserPools = paginateListUserPools;
exports.paginateListUsers = paginateListUsers;
exports.paginateListUsersInGroup = paginateListUsersInGroup;