@aws-sdk/client-cognito-identity-provider/dist-cjs/index.js

AWS SDK for JavaScript Cognito Identity Provider Client for Node.js, Browser and React Native

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  AccountTakeoverEventActionType: () => AccountTakeoverEventActionType,
  AddCustomAttributesCommand: () => AddCustomAttributesCommand,
  AdminAddUserToGroupCommand: () => AdminAddUserToGroupCommand,
  AdminAddUserToGroupRequestFilterSensitiveLog: () => AdminAddUserToGroupRequestFilterSensitiveLog,
  AdminConfirmSignUpCommand: () => AdminConfirmSignUpCommand,
  AdminConfirmSignUpRequestFilterSensitiveLog: () => AdminConfirmSignUpRequestFilterSensitiveLog,
  AdminCreateUserCommand: () => AdminCreateUserCommand,
  AdminCreateUserRequestFilterSensitiveLog: () => AdminCreateUserRequestFilterSensitiveLog,
  AdminCreateUserResponseFilterSensitiveLog: () => AdminCreateUserResponseFilterSensitiveLog,
  AdminDeleteUserAttributesCommand: () => AdminDeleteUserAttributesCommand,
  AdminDeleteUserAttributesRequestFilterSensitiveLog: () => AdminDeleteUserAttributesRequestFilterSensitiveLog,
  AdminDeleteUserCommand: () => AdminDeleteUserCommand,
  AdminDeleteUserRequestFilterSensitiveLog: () => AdminDeleteUserRequestFilterSensitiveLog,
  AdminDisableProviderForUserCommand: () => AdminDisableProviderForUserCommand,
  AdminDisableUserCommand: () => AdminDisableUserCommand,
  AdminDisableUserRequestFilterSensitiveLog: () => AdminDisableUserRequestFilterSensitiveLog,
  AdminEnableUserCommand: () => AdminEnableUserCommand,
  AdminEnableUserRequestFilterSensitiveLog: () => AdminEnableUserRequestFilterSensitiveLog,
  AdminForgetDeviceCommand: () => AdminForgetDeviceCommand,
  AdminForgetDeviceRequestFilterSensitiveLog: () => AdminForgetDeviceRequestFilterSensitiveLog,
  AdminGetDeviceCommand: () => AdminGetDeviceCommand,
  AdminGetDeviceRequestFilterSensitiveLog: () => AdminGetDeviceRequestFilterSensitiveLog,
  AdminGetDeviceResponseFilterSensitiveLog: () => AdminGetDeviceResponseFilterSensitiveLog,
  AdminGetUserCommand: () => AdminGetUserCommand,
  AdminGetUserRequestFilterSensitiveLog: () => AdminGetUserRequestFilterSensitiveLog,
  AdminGetUserResponseFilterSensitiveLog: () => AdminGetUserResponseFilterSensitiveLog,
  AdminInitiateAuthCommand: () => AdminInitiateAuthCommand,
  AdminInitiateAuthRequestFilterSensitiveLog: () => AdminInitiateAuthRequestFilterSensitiveLog,
  AdminInitiateAuthResponseFilterSensitiveLog: () => AdminInitiateAuthResponseFilterSensitiveLog,
  AdminLinkProviderForUserCommand: () => AdminLinkProviderForUserCommand,
  AdminListDevicesCommand: () => AdminListDevicesCommand,
  AdminListDevicesRequestFilterSensitiveLog: () => AdminListDevicesRequestFilterSensitiveLog,
  AdminListDevicesResponseFilterSensitiveLog: () => AdminListDevicesResponseFilterSensitiveLog,
  AdminListGroupsForUserCommand: () => AdminListGroupsForUserCommand,
  AdminListGroupsForUserRequestFilterSensitiveLog: () => AdminListGroupsForUserRequestFilterSensitiveLog,
  AdminListUserAuthEventsCommand: () => AdminListUserAuthEventsCommand,
  AdminListUserAuthEventsRequestFilterSensitiveLog: () => AdminListUserAuthEventsRequestFilterSensitiveLog,
  AdminRemoveUserFromGroupCommand: () => AdminRemoveUserFromGroupCommand,
  AdminRemoveUserFromGroupRequestFilterSensitiveLog: () => AdminRemoveUserFromGroupRequestFilterSensitiveLog,
  AdminResetUserPasswordCommand: () => AdminResetUserPasswordCommand,
  AdminResetUserPasswordRequestFilterSensitiveLog: () => AdminResetUserPasswordRequestFilterSensitiveLog,
  AdminRespondToAuthChallengeCommand: () => AdminRespondToAuthChallengeCommand,
  AdminRespondToAuthChallengeRequestFilterSensitiveLog: () => AdminRespondToAuthChallengeRequestFilterSensitiveLog,
  AdminRespondToAuthChallengeResponseFilterSensitiveLog: () => AdminRespondToAuthChallengeResponseFilterSensitiveLog,
  AdminSetUserMFAPreferenceCommand: () => AdminSetUserMFAPreferenceCommand,
  AdminSetUserMFAPreferenceRequestFilterSensitiveLog: () => AdminSetUserMFAPreferenceRequestFilterSensitiveLog,
  AdminSetUserPasswordCommand: () => AdminSetUserPasswordCommand,
  AdminSetUserPasswordRequestFilterSensitiveLog: () => AdminSetUserPasswordRequestFilterSensitiveLog,
  AdminSetUserSettingsCommand: () => AdminSetUserSettingsCommand,
  AdminSetUserSettingsRequestFilterSensitiveLog: () => AdminSetUserSettingsRequestFilterSensitiveLog,
  AdminUpdateAuthEventFeedbackCommand: () => AdminUpdateAuthEventFeedbackCommand,
  AdminUpdateAuthEventFeedbackRequestFilterSensitiveLog: () => AdminUpdateAuthEventFeedbackRequestFilterSensitiveLog,
  AdminUpdateDeviceStatusCommand: () => AdminUpdateDeviceStatusCommand,
  AdminUpdateDeviceStatusRequestFilterSensitiveLog: () => AdminUpdateDeviceStatusRequestFilterSensitiveLog,
  AdminUpdateUserAttributesCommand: () => AdminUpdateUserAttributesCommand,
  AdminUpdateUserAttributesRequestFilterSensitiveLog: () => AdminUpdateUserAttributesRequestFilterSensitiveLog,
  AdminUserGlobalSignOutCommand: () => AdminUserGlobalSignOutCommand,
  AdminUserGlobalSignOutRequestFilterSensitiveLog: () => AdminUserGlobalSignOutRequestFilterSensitiveLog,
  AdvancedSecurityEnabledModeType: () => AdvancedSecurityEnabledModeType,
  AdvancedSecurityModeType: () => AdvancedSecurityModeType,
  AliasAttributeType: () => AliasAttributeType,
  AliasExistsException: () => AliasExistsException,
  AssetCategoryType: () => AssetCategoryType,
  AssetExtensionType: () => AssetExtensionType,
  AssociateSoftwareTokenCommand: () => AssociateSoftwareTokenCommand,
  AssociateSoftwareTokenRequestFilterSensitiveLog: () => AssociateSoftwareTokenRequestFilterSensitiveLog,
  AssociateSoftwareTokenResponseFilterSensitiveLog: () => AssociateSoftwareTokenResponseFilterSensitiveLog,
  AttributeDataType: () => AttributeDataType,
  AttributeTypeFilterSensitiveLog: () => AttributeTypeFilterSensitiveLog,
  AuthFactorType: () => AuthFactorType,
  AuthFlowType: () => AuthFlowType,
  AuthenticationResultTypeFilterSensitiveLog: () => AuthenticationResultTypeFilterSensitiveLog,
  ChallengeName: () => ChallengeName,
  ChallengeNameType: () => ChallengeNameType,
  ChallengeResponse: () => ChallengeResponse,
  ChangePasswordCommand: () => ChangePasswordCommand,
  ChangePasswordRequestFilterSensitiveLog: () => ChangePasswordRequestFilterSensitiveLog,
  CodeDeliveryFailureException: () => CodeDeliveryFailureException,
  CodeMismatchException: () => CodeMismatchException,
  CognitoIdentityProvider: () => CognitoIdentityProvider,
  CognitoIdentityProviderClient: () => CognitoIdentityProviderClient,
  CognitoIdentityProviderServiceException: () => CognitoIdentityProviderServiceException,
  ColorSchemeModeType: () => ColorSchemeModeType,
  CompleteWebAuthnRegistrationCommand: () => CompleteWebAuthnRegistrationCommand,
  CompleteWebAuthnRegistrationRequestFilterSensitiveLog: () => CompleteWebAuthnRegistrationRequestFilterSensitiveLog,
  CompromisedCredentialsEventActionType: () => CompromisedCredentialsEventActionType,
  ConcurrentModificationException: () => ConcurrentModificationException,
  ConfirmDeviceCommand: () => ConfirmDeviceCommand,
  ConfirmDeviceRequestFilterSensitiveLog: () => ConfirmDeviceRequestFilterSensitiveLog,
  ConfirmForgotPasswordCommand: () => ConfirmForgotPasswordCommand,
  ConfirmForgotPasswordRequestFilterSensitiveLog: () => ConfirmForgotPasswordRequestFilterSensitiveLog,
  ConfirmSignUpCommand: () => ConfirmSignUpCommand,
  ConfirmSignUpRequestFilterSensitiveLog: () => ConfirmSignUpRequestFilterSensitiveLog,
  ConfirmSignUpResponseFilterSensitiveLog: () => ConfirmSignUpResponseFilterSensitiveLog,
  CreateGroupCommand: () => CreateGroupCommand,
  CreateIdentityProviderCommand: () => CreateIdentityProviderCommand,
  CreateManagedLoginBrandingCommand: () => CreateManagedLoginBrandingCommand,
  CreateManagedLoginBrandingRequestFilterSensitiveLog: () => CreateManagedLoginBrandingRequestFilterSensitiveLog,
  CreateResourceServerCommand: () => CreateResourceServerCommand,
  CreateUserImportJobCommand: () => CreateUserImportJobCommand,
  CreateUserPoolClientCommand: () => CreateUserPoolClientCommand,
  CreateUserPoolClientResponseFilterSensitiveLog: () => CreateUserPoolClientResponseFilterSensitiveLog,
  CreateUserPoolCommand: () => CreateUserPoolCommand,
  CreateUserPoolDomainCommand: () => CreateUserPoolDomainCommand,
  CustomEmailSenderLambdaVersionType: () => CustomEmailSenderLambdaVersionType,
  CustomSMSSenderLambdaVersionType: () => CustomSMSSenderLambdaVersionType,
  DefaultEmailOptionType: () => DefaultEmailOptionType,
  DeleteGroupCommand: () => DeleteGroupCommand,
  DeleteIdentityProviderCommand: () => DeleteIdentityProviderCommand,
  DeleteManagedLoginBrandingCommand: () => DeleteManagedLoginBrandingCommand,
  DeleteResourceServerCommand: () => DeleteResourceServerCommand,
  DeleteUserAttributesCommand: () => DeleteUserAttributesCommand,
  DeleteUserAttributesRequestFilterSensitiveLog: () => DeleteUserAttributesRequestFilterSensitiveLog,
  DeleteUserCommand: () => DeleteUserCommand,
  DeleteUserPoolClientCommand: () => DeleteUserPoolClientCommand,
  DeleteUserPoolClientRequestFilterSensitiveLog: () => DeleteUserPoolClientRequestFilterSensitiveLog,
  DeleteUserPoolCommand: () => DeleteUserPoolCommand,
  DeleteUserPoolDomainCommand: () => DeleteUserPoolDomainCommand,
  DeleteUserRequestFilterSensitiveLog: () => DeleteUserRequestFilterSensitiveLog,
  DeleteWebAuthnCredentialCommand: () => DeleteWebAuthnCredentialCommand,
  DeleteWebAuthnCredentialRequestFilterSensitiveLog: () => DeleteWebAuthnCredentialRequestFilterSensitiveLog,
  DeletionProtectionType: () => DeletionProtectionType,
  DeliveryMediumType: () => DeliveryMediumType,
  DescribeIdentityProviderCommand: () => DescribeIdentityProviderCommand,
  DescribeManagedLoginBrandingByClientCommand: () => DescribeManagedLoginBrandingByClientCommand,
  DescribeManagedLoginBrandingByClientRequestFilterSensitiveLog: () => DescribeManagedLoginBrandingByClientRequestFilterSensitiveLog,
  DescribeManagedLoginBrandingCommand: () => DescribeManagedLoginBrandingCommand,
  DescribeResourceServerCommand: () => DescribeResourceServerCommand,
  DescribeRiskConfigurationCommand: () => DescribeRiskConfigurationCommand,
  DescribeRiskConfigurationRequestFilterSensitiveLog: () => DescribeRiskConfigurationRequestFilterSensitiveLog,
  DescribeRiskConfigurationResponseFilterSensitiveLog: () => DescribeRiskConfigurationResponseFilterSensitiveLog,
  DescribeUserImportJobCommand: () => DescribeUserImportJobCommand,
  DescribeUserPoolClientCommand: () => DescribeUserPoolClientCommand,
  DescribeUserPoolClientRequestFilterSensitiveLog: () => DescribeUserPoolClientRequestFilterSensitiveLog,
  DescribeUserPoolClientResponseFilterSensitiveLog: () => DescribeUserPoolClientResponseFilterSensitiveLog,
  DescribeUserPoolCommand: () => DescribeUserPoolCommand,
  DescribeUserPoolDomainCommand: () => DescribeUserPoolDomainCommand,
  DeviceRememberedStatusType: () => DeviceRememberedStatusType,
  DeviceTypeFilterSensitiveLog: () => DeviceTypeFilterSensitiveLog,
  DomainStatusType: () => DomainStatusType,
  DuplicateProviderException: () => DuplicateProviderException,
  EmailSendingAccountType: () => EmailSendingAccountType,
  EnableSoftwareTokenMFAException: () => EnableSoftwareTokenMFAException,
  EventFilterType: () => EventFilterType,
  EventResponseType: () => EventResponseType,
  EventSourceName: () => EventSourceName,
  EventType: () => EventType,
  ExpiredCodeException: () => ExpiredCodeException,
  ExplicitAuthFlowsType: () => ExplicitAuthFlowsType,
  FeatureUnavailableInTierException: () => FeatureUnavailableInTierException,
  FeedbackValueType: () => FeedbackValueType,
  ForbiddenException: () => ForbiddenException,
  ForgetDeviceCommand: () => ForgetDeviceCommand,
  ForgetDeviceRequestFilterSensitiveLog: () => ForgetDeviceRequestFilterSensitiveLog,
  ForgotPasswordCommand: () => ForgotPasswordCommand,
  ForgotPasswordRequestFilterSensitiveLog: () => ForgotPasswordRequestFilterSensitiveLog,
  GetCSVHeaderCommand: () => GetCSVHeaderCommand,
  GetDeviceCommand: () => GetDeviceCommand,
  GetDeviceRequestFilterSensitiveLog: () => GetDeviceRequestFilterSensitiveLog,
  GetDeviceResponseFilterSensitiveLog: () => GetDeviceResponseFilterSensitiveLog,
  GetGroupCommand: () => GetGroupCommand,
  GetIdentityProviderByIdentifierCommand: () => GetIdentityProviderByIdentifierCommand,
  GetLogDeliveryConfigurationCommand: () => GetLogDeliveryConfigurationCommand,
  GetSigningCertificateCommand: () => GetSigningCertificateCommand,
  GetUICustomizationCommand: () => GetUICustomizationCommand,
  GetUICustomizationRequestFilterSensitiveLog: () => GetUICustomizationRequestFilterSensitiveLog,
  GetUICustomizationResponseFilterSensitiveLog: () => GetUICustomizationResponseFilterSensitiveLog,
  GetUserAttributeVerificationCodeCommand: () => GetUserAttributeVerificationCodeCommand,
  GetUserAttributeVerificationCodeRequestFilterSensitiveLog: () => GetUserAttributeVerificationCodeRequestFilterSensitiveLog,
  GetUserAuthFactorsCommand: () => GetUserAuthFactorsCommand,
  GetUserAuthFactorsRequestFilterSensitiveLog: () => GetUserAuthFactorsRequestFilterSensitiveLog,
  GetUserAuthFactorsResponseFilterSensitiveLog: () => GetUserAuthFactorsResponseFilterSensitiveLog,
  GetUserCommand: () => GetUserCommand,
  GetUserPoolMfaConfigCommand: () => GetUserPoolMfaConfigCommand,
  GetUserRequestFilterSensitiveLog: () => GetUserRequestFilterSensitiveLog,
  GetUserResponseFilterSensitiveLog: () => GetUserResponseFilterSensitiveLog,
  GlobalSignOutCommand: () => GlobalSignOutCommand,
  GlobalSignOutRequestFilterSensitiveLog: () => GlobalSignOutRequestFilterSensitiveLog,
  GroupExistsException: () => GroupExistsException,
  IdentityProviderTypeType: () => IdentityProviderTypeType,
  InitiateAuthCommand: () => InitiateAuthCommand,
  InitiateAuthRequestFilterSensitiveLog: () => InitiateAuthRequestFilterSensitiveLog,
  InitiateAuthResponseFilterSensitiveLog: () => InitiateAuthResponseFilterSensitiveLog,
  InternalErrorException: () => InternalErrorException,
  InvalidEmailRoleAccessPolicyException: () => InvalidEmailRoleAccessPolicyException,
  InvalidLambdaResponseException: () => InvalidLambdaResponseException,
  InvalidOAuthFlowException: () => InvalidOAuthFlowException,
  InvalidParameterException: () => InvalidParameterException,
  InvalidPasswordException: () => InvalidPasswordException,
  InvalidSmsRoleAccessPolicyException: () => InvalidSmsRoleAccessPolicyException,
  InvalidSmsRoleTrustRelationshipException: () => InvalidSmsRoleTrustRelationshipException,
  InvalidUserPoolConfigurationException: () => InvalidUserPoolConfigurationException,
  LimitExceededException: () => LimitExceededException,
  ListDevicesCommand: () => ListDevicesCommand,
  ListDevicesRequestFilterSensitiveLog: () => ListDevicesRequestFilterSensitiveLog,
  ListDevicesResponseFilterSensitiveLog: () => ListDevicesResponseFilterSensitiveLog,
  ListGroupsCommand: () => ListGroupsCommand,
  ListIdentityProvidersCommand: () => ListIdentityProvidersCommand,
  ListResourceServersCommand: () => ListResourceServersCommand,
  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
  ListUserImportJobsCommand: () => ListUserImportJobsCommand,
  ListUserPoolClientsCommand: () => ListUserPoolClientsCommand,
  ListUserPoolClientsResponseFilterSensitiveLog: () => ListUserPoolClientsResponseFilterSensitiveLog,
  ListUserPoolsCommand: () => ListUserPoolsCommand,
  ListUsersCommand: () => ListUsersCommand,
  ListUsersInGroupCommand: () => ListUsersInGroupCommand,
  ListUsersInGroupResponseFilterSensitiveLog: () => ListUsersInGroupResponseFilterSensitiveLog,
  ListUsersResponseFilterSensitiveLog: () => ListUsersResponseFilterSensitiveLog,
  ListWebAuthnCredentialsCommand: () => ListWebAuthnCredentialsCommand,
  ListWebAuthnCredentialsRequestFilterSensitiveLog: () => ListWebAuthnCredentialsRequestFilterSensitiveLog,
  LogLevel: () => LogLevel,
  MFAMethodNotFoundException: () => MFAMethodNotFoundException,
  ManagedLoginBrandingExistsException: () => ManagedLoginBrandingExistsException,
  MessageActionType: () => MessageActionType,
  NotAuthorizedException: () => NotAuthorizedException,
  OAuthFlowType: () => OAuthFlowType,
  PasswordHistoryPolicyViolationException: () => PasswordHistoryPolicyViolationException,
  PasswordResetRequiredException: () => PasswordResetRequiredException,
  PreTokenGenerationLambdaVersionType: () => PreTokenGenerationLambdaVersionType,
  PreconditionNotMetException: () => PreconditionNotMetException,
  PreventUserExistenceErrorTypes: () => PreventUserExistenceErrorTypes,
  RecoveryOptionNameType: () => RecoveryOptionNameType,
  ResendConfirmationCodeCommand: () => ResendConfirmationCodeCommand,
  ResendConfirmationCodeRequestFilterSensitiveLog: () => ResendConfirmationCodeRequestFilterSensitiveLog,
  ResourceNotFoundException: () => ResourceNotFoundException,
  RespondToAuthChallengeCommand: () => RespondToAuthChallengeCommand,
  RespondToAuthChallengeRequestFilterSensitiveLog: () => RespondToAuthChallengeRequestFilterSensitiveLog,
  RespondToAuthChallengeResponseFilterSensitiveLog: () => RespondToAuthChallengeResponseFilterSensitiveLog,
  RevokeTokenCommand: () => RevokeTokenCommand,
  RevokeTokenRequestFilterSensitiveLog: () => RevokeTokenRequestFilterSensitiveLog,
  RiskConfigurationTypeFilterSensitiveLog: () => RiskConfigurationTypeFilterSensitiveLog,
  RiskDecisionType: () => RiskDecisionType,
  RiskLevelType: () => RiskLevelType,
  ScopeDoesNotExistException: () => ScopeDoesNotExistException,
  SetLogDeliveryConfigurationCommand: () => SetLogDeliveryConfigurationCommand,
  SetRiskConfigurationCommand: () => SetRiskConfigurationCommand,
  SetRiskConfigurationRequestFilterSensitiveLog: () => SetRiskConfigurationRequestFilterSensitiveLog,
  SetRiskConfigurationResponseFilterSensitiveLog: () => SetRiskConfigurationResponseFilterSensitiveLog,
  SetUICustomizationCommand: () => SetUICustomizationCommand,
  SetUICustomizationRequestFilterSensitiveLog: () => SetUICustomizationRequestFilterSensitiveLog,
  SetUICustomizationResponseFilterSensitiveLog: () => SetUICustomizationResponseFilterSensitiveLog,
  SetUserMFAPreferenceCommand: () => SetUserMFAPreferenceCommand,
  SetUserMFAPreferenceRequestFilterSensitiveLog: () => SetUserMFAPreferenceRequestFilterSensitiveLog,
  SetUserPoolMfaConfigCommand: () => SetUserPoolMfaConfigCommand,
  SetUserSettingsCommand: () => SetUserSettingsCommand,
  SetUserSettingsRequestFilterSensitiveLog: () => SetUserSettingsRequestFilterSensitiveLog,
  SignUpCommand: () => SignUpCommand,
  SignUpRequestFilterSensitiveLog: () => SignUpRequestFilterSensitiveLog,
  SignUpResponseFilterSensitiveLog: () => SignUpResponseFilterSensitiveLog,
  SoftwareTokenMFANotFoundException: () => SoftwareTokenMFANotFoundException,
  StartUserImportJobCommand: () => StartUserImportJobCommand,
  StartWebAuthnRegistrationCommand: () => StartWebAuthnRegistrationCommand,
  StartWebAuthnRegistrationRequestFilterSensitiveLog: () => StartWebAuthnRegistrationRequestFilterSensitiveLog,
  StatusType: () => StatusType,
  StopUserImportJobCommand: () => StopUserImportJobCommand,
  TagResourceCommand: () => TagResourceCommand,
  TierChangeNotAllowedException: () => TierChangeNotAllowedException,
  TimeUnitsType: () => TimeUnitsType,
  TooManyFailedAttemptsException: () => TooManyFailedAttemptsException,
  TooManyRequestsException: () => TooManyRequestsException,
  UICustomizationTypeFilterSensitiveLog: () => UICustomizationTypeFilterSensitiveLog,
  UnauthorizedException: () => UnauthorizedException,
  UnexpectedLambdaException: () => UnexpectedLambdaException,
  UnsupportedIdentityProviderException: () => UnsupportedIdentityProviderException,
  UnsupportedOperationException: () => UnsupportedOperationException,
  UnsupportedTokenTypeException: () => UnsupportedTokenTypeException,
  UnsupportedUserStateException: () => UnsupportedUserStateException,
  UntagResourceCommand: () => UntagResourceCommand,
  UpdateAuthEventFeedbackCommand: () => UpdateAuthEventFeedbackCommand,
  UpdateAuthEventFeedbackRequestFilterSensitiveLog: () => UpdateAuthEventFeedbackRequestFilterSensitiveLog,
  UpdateDeviceStatusCommand: () => UpdateDeviceStatusCommand,
  UpdateDeviceStatusRequestFilterSensitiveLog: () => UpdateDeviceStatusRequestFilterSensitiveLog,
  UpdateGroupCommand: () => UpdateGroupCommand,
  UpdateIdentityProviderCommand: () => UpdateIdentityProviderCommand,
  UpdateManagedLoginBrandingCommand: () => UpdateManagedLoginBrandingCommand,
  UpdateResourceServerCommand: () => UpdateResourceServerCommand,
  UpdateUserAttributesCommand: () => UpdateUserAttributesCommand,
  UpdateUserAttributesRequestFilterSensitiveLog: () => UpdateUserAttributesRequestFilterSensitiveLog,
  UpdateUserPoolClientCommand: () => UpdateUserPoolClientCommand,
  UpdateUserPoolClientRequestFilterSensitiveLog: () => UpdateUserPoolClientRequestFilterSensitiveLog,
  UpdateUserPoolClientResponseFilterSensitiveLog: () => UpdateUserPoolClientResponseFilterSensitiveLog,
  UpdateUserPoolCommand: () => UpdateUserPoolCommand,
  UpdateUserPoolDomainCommand: () => UpdateUserPoolDomainCommand,
  UserContextDataTypeFilterSensitiveLog: () => UserContextDataTypeFilterSensitiveLog,
  UserImportInProgressException: () => UserImportInProgressException,
  UserImportJobStatusType: () => UserImportJobStatusType,
  UserLambdaValidationException: () => UserLambdaValidationException,
  UserNotConfirmedException: () => UserNotConfirmedException,
  UserNotFoundException: () => UserNotFoundException,
  UserPoolAddOnNotEnabledException: () => UserPoolAddOnNotEnabledException,
  UserPoolClientDescriptionFilterSensitiveLog: () => UserPoolClientDescriptionFilterSensitiveLog,
  UserPoolClientTypeFilterSensitiveLog: () => UserPoolClientTypeFilterSensitiveLog,
  UserPoolMfaType: () => UserPoolMfaType,
  UserPoolTaggingException: () => UserPoolTaggingException,
  UserPoolTierType: () => UserPoolTierType,
  UserStatusType: () => UserStatusType,
  UserTypeFilterSensitiveLog: () => UserTypeFilterSensitiveLog,
  UserVerificationType: () => UserVerificationType,
  UsernameAttributeType: () => UsernameAttributeType,
  UsernameExistsException: () => UsernameExistsException,
  VerifiedAttributeType: () => VerifiedAttributeType,
  VerifySoftwareTokenCommand: () => VerifySoftwareTokenCommand,
  VerifySoftwareTokenRequestFilterSensitiveLog: () => VerifySoftwareTokenRequestFilterSensitiveLog,
  VerifySoftwareTokenResponseFilterSensitiveLog: () => VerifySoftwareTokenResponseFilterSensitiveLog,
  VerifySoftwareTokenResponseType: () => VerifySoftwareTokenResponseType,
  VerifyUserAttributeCommand: () => VerifyUserAttributeCommand,
  VerifyUserAttributeRequestFilterSensitiveLog: () => VerifyUserAttributeRequestFilterSensitiveLog,
  WebAuthnChallengeNotFoundException: () => WebAuthnChallengeNotFoundException,
  WebAuthnClientMismatchException: () => WebAuthnClientMismatchException,
  WebAuthnConfigurationMissingException: () => WebAuthnConfigurationMissingException,
  WebAuthnCredentialNotSupportedException: () => WebAuthnCredentialNotSupportedException,
  WebAuthnNotEnabledException: () => WebAuthnNotEnabledException,
  WebAuthnOriginNotAllowedException: () => WebAuthnOriginNotAllowedException,
  WebAuthnRelyingPartyMismatchException: () => WebAuthnRelyingPartyMismatchException,
  __Client: () => import_smithy_client.Client,
  paginateAdminListGroupsForUser: () => paginateAdminListGroupsForUser,
  paginateAdminListUserAuthEvents: () => paginateAdminListUserAuthEvents,
  paginateListGroups: () => paginateListGroups,
  paginateListIdentityProviders: () => paginateListIdentityProviders,
  paginateListResourceServers: () => paginateListResourceServers,
  paginateListUserPoolClients: () => paginateListUserPoolClients,
  paginateListUserPools: () => paginateListUserPools,
  paginateListUsers: () => paginateListUsers,
  paginateListUsersInGroup: () => paginateListUsersInGroup
});
module.exports = __toCommonJS(src_exports);

// src/CognitoIdentityProviderClient.ts
var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
var import_middleware_logger = require("@aws-sdk/middleware-logger");
var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
var import_config_resolver = require("@smithy/config-resolver");
var import_core = require("@smithy/core");
var import_middleware_content_length = require("@smithy/middleware-content-length");
var import_middleware_endpoint = require("@smithy/middleware-endpoint");
var import_middleware_retry = require("@smithy/middleware-retry");

var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");

// src/endpoint/EndpointParameters.ts
var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
  return {
    ...options,
    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
    useFipsEndpoint: options.useFipsEndpoint ?? false,
    defaultSigningName: "cognito-idp"
  };
}, "resolveClientEndpointParameters");
var commonParams = {
  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
  Endpoint: { type: "builtInParams", name: "endpoint" },
  Region: { type: "builtInParams", name: "region" },
  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};

// src/CognitoIdentityProviderClient.ts
var import_runtimeConfig = require("././runtimeConfig");

// src/runtimeExtensions.ts
var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
var import_protocol_http = require("@smithy/protocol-http");
var import_smithy_client = require("@smithy/smithy-client");

// src/auth/httpAuthExtensionConfiguration.ts
var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((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;
    }
  };
}, "getHttpAuthExtensionConfiguration");
var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
  return {
    httpAuthSchemes: config.httpAuthSchemes(),
    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
    credentials: config.credentials()
  };
}, "resolveHttpAuthRuntimeConfig");

// src/runtimeExtensions.ts
var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
  const extensionConfiguration = {
    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig)),
    ...asPartial(getHttpAuthExtensionConfiguration(runtimeConfig))
  };
  extensions.forEach((extension) => extension.configure(extensionConfiguration));
  return {
    ...runtimeConfig,
    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
    ...resolveHttpAuthRuntimeConfig(extensionConfiguration)
  };
}, "resolveRuntimeExtensions");

// src/CognitoIdentityProviderClient.ts
var _CognitoIdentityProviderClient = class _CognitoIdentityProviderClient extends import_smithy_client.Client {
  constructor(...[configuration]) {
    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
    const _config_1 = resolveClientEndpointParameters(_config_0);
    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
    super(_config_8);
    this.config = _config_8;
    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
    this.middlewareStack.use(
      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultCognitoIdentityProviderHttpAuthSchemeParametersProvider,
        identityProviderConfigProvider: async (config) => new import_core.DefaultIdentityProviderConfig({
          "aws.auth#sigv4": config.credentials
        })
      })
    );
    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
  }
  /**
   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
   */
  destroy() {
    super.destroy();
  }
};
__name(_CognitoIdentityProviderClient, "CognitoIdentityProviderClient");
var CognitoIdentityProviderClient = _CognitoIdentityProviderClient;

// src/CognitoIdentityProvider.ts


// src/commands/AddCustomAttributesCommand.ts

var import_middleware_serde = require("@smithy/middleware-serde");


// src/protocols/Aws_json1_1.ts
var import_core2 = require("@aws-sdk/core");



// src/models/CognitoIdentityProviderServiceException.ts

var _CognitoIdentityProviderServiceException = class _CognitoIdentityProviderServiceException extends import_smithy_client.ServiceException {
  /**
   * @internal
   */
  constructor(options) {
    super(options);
    Object.setPrototypeOf(this, _CognitoIdentityProviderServiceException.prototype);
  }
};
__name(_CognitoIdentityProviderServiceException, "CognitoIdentityProviderServiceException");
var CognitoIdentityProviderServiceException = _CognitoIdentityProviderServiceException;

// src/models/models_0.ts

var RecoveryOptionNameType = {
  ADMIN_ONLY: "admin_only",
  VERIFIED_EMAIL: "verified_email",
  VERIFIED_PHONE_NUMBER: "verified_phone_number"
};
var AccountTakeoverEventActionType = {
  BLOCK: "BLOCK",
  MFA_IF_CONFIGURED: "MFA_IF_CONFIGURED",
  MFA_REQUIRED: "MFA_REQUIRED",
  NO_ACTION: "NO_ACTION"
};
var AttributeDataType = {
  BOOLEAN: "Boolean",
  DATETIME: "DateTime",
  NUMBER: "Number",
  STRING: "String"
};
var _InternalErrorException = class _InternalErrorException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InternalErrorException",
      $fault: "server",
      ...opts
    });
    this.name = "InternalErrorException";
    this.$fault = "server";
    Object.setPrototypeOf(this, _InternalErrorException.prototype);
  }
};
__name(_InternalErrorException, "InternalErrorException");
var InternalErrorException = _InternalErrorException;
var _InvalidParameterException = class _InvalidParameterException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidParameterException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidParameterException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidParameterException.prototype);
    this.reasonCode = opts.reasonCode;
  }
};
__name(_InvalidParameterException, "InvalidParameterException");
var InvalidParameterException = _InvalidParameterException;
var _NotAuthorizedException = class _NotAuthorizedException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "NotAuthorizedException",
      $fault: "client",
      ...opts
    });
    this.name = "NotAuthorizedException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _NotAuthorizedException.prototype);
  }
};
__name(_NotAuthorizedException, "NotAuthorizedException");
var NotAuthorizedException = _NotAuthorizedException;
var _ResourceNotFoundException = class _ResourceNotFoundException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
  }
};
__name(_ResourceNotFoundException, "ResourceNotFoundException");
var ResourceNotFoundException = _ResourceNotFoundException;
var _TooManyRequestsException = class _TooManyRequestsException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TooManyRequestsException",
      $fault: "client",
      ...opts
    });
    this.name = "TooManyRequestsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _TooManyRequestsException.prototype);
  }
};
__name(_TooManyRequestsException, "TooManyRequestsException");
var TooManyRequestsException = _TooManyRequestsException;
var _UserImportInProgressException = class _UserImportInProgressException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UserImportInProgressException",
      $fault: "client",
      ...opts
    });
    this.name = "UserImportInProgressException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _UserImportInProgressException.prototype);
  }
};
__name(_UserImportInProgressException, "UserImportInProgressException");
var UserImportInProgressException = _UserImportInProgressException;
var _UserNotFoundException = class _UserNotFoundException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UserNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "UserNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _UserNotFoundException.prototype);
  }
};
__name(_UserNotFoundException, "UserNotFoundException");
var UserNotFoundException = _UserNotFoundException;
var _InvalidLambdaResponseException = class _InvalidLambdaResponseException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidLambdaResponseException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidLambdaResponseException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidLambdaResponseException.prototype);
  }
};
__name(_InvalidLambdaResponseException, "InvalidLambdaResponseException");
var InvalidLambdaResponseException = _InvalidLambdaResponseException;
var _LimitExceededException = class _LimitExceededException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "LimitExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "LimitExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _LimitExceededException.prototype);
  }
};
__name(_LimitExceededException, "LimitExceededException");
var LimitExceededException = _LimitExceededException;
var _TooManyFailedAttemptsException = class _TooManyFailedAttemptsException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TooManyFailedAttemptsException",
      $fault: "client",
      ...opts
    });
    this.name = "TooManyFailedAttemptsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _TooManyFailedAttemptsException.prototype);
  }
};
__name(_TooManyFailedAttemptsException, "TooManyFailedAttemptsException");
var TooManyFailedAttemptsException = _TooManyFailedAttemptsException;
var _UnexpectedLambdaException = class _UnexpectedLambdaException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UnexpectedLambdaException",
      $fault: "client",
      ...opts
    });
    this.name = "UnexpectedLambdaException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _UnexpectedLambdaException.prototype);
  }
};
__name(_UnexpectedLambdaException, "UnexpectedLambdaException");
var UnexpectedLambdaException = _UnexpectedLambdaException;
var _UserLambdaValidationException = class _UserLambdaValidationException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UserLambdaValidationException",
      $fault: "client",
      ...opts
    });
    this.name = "UserLambdaValidationException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _UserLambdaValidationException.prototype);
  }
};
__name(_UserLambdaValidationException, "UserLambdaValidationException");
var UserLambdaValidationException = _UserLambdaValidationException;
var DeliveryMediumType = {
  EMAIL: "EMAIL",
  SMS: "SMS"
};
var MessageActionType = {
  RESEND: "RESEND",
  SUPPRESS: "SUPPRESS"
};
var 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"
};
var _CodeDeliveryFailureException = class _CodeDeliveryFailureException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CodeDeliveryFailureException",
      $fault: "client",
      ...opts
    });
    this.name = "CodeDeliveryFailureException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _CodeDeliveryFailureException.prototype);
  }
};
__name(_CodeDeliveryFailureException, "CodeDeliveryFailureException");
var CodeDeliveryFailureException = _CodeDeliveryFailureException;
var _InvalidPasswordException = class _InvalidPasswordException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidPasswordException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidPasswordException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidPasswordException.prototype);
  }
};
__name(_InvalidPasswordException, "InvalidPasswordException");
var InvalidPasswordException = _InvalidPasswordException;
var _InvalidSmsRoleAccessPolicyException = class _InvalidSmsRoleAccessPolicyException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidSmsRoleAccessPolicyException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidSmsRoleAccessPolicyException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidSmsRoleAccessPolicyException.prototype);
  }
};
__name(_InvalidSmsRoleAccessPolicyException, "InvalidSmsRoleAccessPolicyException");
var InvalidSmsRoleAccessPolicyException = _InvalidSmsRoleAccessPolicyException;
var _InvalidSmsRoleTrustRelationshipException = class _InvalidSmsRoleTrustRelationshipException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidSmsRoleTrustRelationshipException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidSmsRoleTrustRelationshipException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidSmsRoleTrustRelationshipException.prototype);
  }
};
__name(_InvalidSmsRoleTrustRelationshipException, "InvalidSmsRoleTrustRelationshipException");
var InvalidSmsRoleTrustRelationshipException = _InvalidSmsRoleTrustRelationshipException;
var _PreconditionNotMetException = class _PreconditionNotMetException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "PreconditionNotMetException",
      $fault: "client",
      ...opts
    });
    this.name = "PreconditionNotMetException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _PreconditionNotMetException.prototype);
  }
};
__name(_PreconditionNotMetException, "PreconditionNotMetException");
var PreconditionNotMetException = _PreconditionNotMetException;
var _UnsupportedUserStateException = class _UnsupportedUserStateException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UnsupportedUserStateException",
      $fault: "client",
      ...opts
    });
    this.name = "UnsupportedUserStateException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _UnsupportedUserStateException.prototype);
  }
};
__name(_UnsupportedUserStateException, "UnsupportedUserStateException");
var UnsupportedUserStateException = _UnsupportedUserStateException;
var _UsernameExistsException = class _UsernameExistsException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UsernameExistsException",
      $fault: "client",
      ...opts
    });
    this.name = "UsernameExistsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _UsernameExistsException.prototype);
  }
};
__name(_UsernameExistsException, "UsernameExistsException");
var UsernameExistsException = _UsernameExistsException;
var _AliasExistsException = class _AliasExistsException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "AliasExistsException",
      $fault: "client",
      ...opts
    });
    this.name = "AliasExistsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _AliasExistsException.prototype);
  }
};
__name(_AliasExistsException, "AliasExistsException");
var AliasExistsException = _AliasExistsException;
var _InvalidUserPoolConfigurationException = class _InvalidUserPoolConfigurationException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidUserPoolConfigurationException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidUserPoolConfigurationException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidUserPoolConfigurationException.prototype);
  }
};
__name(_InvalidUserPoolConfigurationException, "InvalidUserPoolConfigurationException");
var InvalidUserPoolConfigurationException = _InvalidUserPoolConfigurationException;
var 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"
};
var 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"
};
var _InvalidEmailRoleAccessPolicyException = class _InvalidEmailRoleAccessPolicyException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidEmailRoleAccessPolicyException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidEmailRoleAccessPolicyException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidEmailRoleAccessPolicyException.prototype);
  }
};
__name(_InvalidEmailRoleAccessPolicyException, "InvalidEmailRoleAccessPolicyException");
var InvalidEmailRoleAccessPolicyException = _InvalidEmailRoleAccessPolicyException;
var _MFAMethodNotFoundException = class _MFAMethodNotFoundException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "MFAMethodNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "MFAMethodNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _MFAMethodNotFoundException.prototype);
  }
};
__name(_MFAMethodNotFoundException, "MFAMethodNotFoundException");
var MFAMethodNotFoundException = _MFAMethodNotFoundException;
var _PasswordResetRequiredException = class _PasswordResetRequiredException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "PasswordResetRequiredException",
      $fault: "client",
      ...opts
    });
    this.name = "PasswordResetRequiredException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _PasswordResetRequiredException.prototype);
  }
};
__name(_PasswordResetRequiredException, "PasswordResetRequiredException");
var PasswordResetRequiredException = _PasswordResetRequiredException;
var _UserNotConfirmedException = class _UserNotConfirmedException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UserNotConfirmedException",
      $fault: "client",
      ...opts
    });
    this.name = "UserNotConfirmedException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _UserNotConfirmedException.prototype);
  }
};
__name(_UserNotConfirmedException, "UserNotConfirmedException");
var UserNotConfirmedException = _UserNotConfirmedException;
var ChallengeName = {
  Mfa: "Mfa",
  Password: "Password"
};
var ChallengeResponse = {
  Failure: "Failure",
  Success: "Success"
};
var FeedbackValueType = {
  INVALID: "Invalid",
  VALID: "Valid"
};
var EventResponseType = {
  Fail: "Fail",
  InProgress: "InProgress",
  Pass: "Pass"
};
var RiskDecisionType = {
  AccountTakeover: "AccountTakeover",
  Block: "Block",
  NoRisk: "NoRisk"
};
var RiskLevelType = {
  High: "High",
  Low: "Low",
  Medium: "Medium"
};
var EventType = {
  ForgotPassword: "ForgotPassword",
  PasswordChange: "PasswordChange",
  ResendCode: "ResendCode",
  SignIn: "SignIn",
  SignUp: "SignUp"
};
var _UserPoolAddOnNotEnabledException = class _UserPoolAddOnNotEnabledException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UserPoolAddOnNotEnabledException",
      $fault: "client",
      ...opts
    });
    this.name = "UserPoolAddOnNotEnabledException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _UserPoolAddOnNotEnabledException.prototype);
  }
};
__name(_UserPoolAddOnNotEnabledException, "UserPoolAddOnNotEnabledException");
var UserPoolAddOnNotEnabledException = _UserPoolAddOnNotEnabledException;
var _CodeMismatchException = class _CodeMismatchException extends CognitoIdentityProviderServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "CodeMismatchException",
      $fault: "client",
      ...opts
    });
    this.name = "CodeMismatchException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _CodeMismatchException.prototype);
  }
};
__name(_CodeMismatchException, "CodeMismatchException");
var CodeMismatchException = _CodeMismatchException;
var _ExpiredCodeException = class _ExpiredCodeException extends CognitoIdentityProviderServiceException {
  /**