@firebase/auth 0.20.11 → 0.21.0

package/dist/esm2017/{index-0bb4da3b.js → index-c6def6da.js}

@@ -120,147 +120,147 @@ const ActionCodeOperation = {
  */
 function _debugErrorMap() {
     return {
-        ["admin-restricted-operation" /* ADMIN_ONLY_OPERATION */]: 'This operation is restricted to administrators only.',
-        ["argument-error" /* ARGUMENT_ERROR */]: '',
-        ["app-not-authorized" /* APP_NOT_AUTHORIZED */]: "This app, identified by the domain where it's hosted, is not " +
+        ["admin-restricted-operation" /* AuthErrorCode.ADMIN_ONLY_OPERATION */]: 'This operation is restricted to administrators only.',
+        ["argument-error" /* AuthErrorCode.ARGUMENT_ERROR */]: '',
+        ["app-not-authorized" /* AuthErrorCode.APP_NOT_AUTHORIZED */]: "This app, identified by the domain where it's hosted, is not " +
             'authorized to use Firebase Authentication with the provided API key. ' +
             'Review your key configuration in the Google API console.',
-        ["app-not-installed" /* APP_NOT_INSTALLED */]: 'The requested mobile application corresponding to the identifier (' +
+        ["app-not-installed" /* AuthErrorCode.APP_NOT_INSTALLED */]: 'The requested mobile application corresponding to the identifier (' +
             'Android package name or iOS bundle ID) provided is not installed on ' +
             'this device.',
-        ["captcha-check-failed" /* CAPTCHA_CHECK_FAILED */]: 'The reCAPTCHA response token provided is either invalid, expired, ' +
+        ["captcha-check-failed" /* AuthErrorCode.CAPTCHA_CHECK_FAILED */]: 'The reCAPTCHA response token provided is either invalid, expired, ' +
             'already used or the domain associated with it does not match the list ' +
             'of whitelisted domains.',
-        ["code-expired" /* CODE_EXPIRED */]: 'The SMS code has expired. Please re-send the verification code to try ' +
+        ["code-expired" /* AuthErrorCode.CODE_EXPIRED */]: 'The SMS code has expired. Please re-send the verification code to try ' +
             'again.',
-        ["cordova-not-ready" /* CORDOVA_NOT_READY */]: 'Cordova framework is not ready.',
-        ["cors-unsupported" /* CORS_UNSUPPORTED */]: 'This browser is not supported.',
-        ["credential-already-in-use" /* CREDENTIAL_ALREADY_IN_USE */]: 'This credential is already associated with a different user account.',
-        ["custom-token-mismatch" /* CREDENTIAL_MISMATCH */]: 'The custom token corresponds to a different audience.',
-        ["requires-recent-login" /* CREDENTIAL_TOO_OLD_LOGIN_AGAIN */]: 'This operation is sensitive and requires recent authentication. Log in ' +
+        ["cordova-not-ready" /* AuthErrorCode.CORDOVA_NOT_READY */]: 'Cordova framework is not ready.',
+        ["cors-unsupported" /* AuthErrorCode.CORS_UNSUPPORTED */]: 'This browser is not supported.',
+        ["credential-already-in-use" /* AuthErrorCode.CREDENTIAL_ALREADY_IN_USE */]: 'This credential is already associated with a different user account.',
+        ["custom-token-mismatch" /* AuthErrorCode.CREDENTIAL_MISMATCH */]: 'The custom token corresponds to a different audience.',
+        ["requires-recent-login" /* AuthErrorCode.CREDENTIAL_TOO_OLD_LOGIN_AGAIN */]: 'This operation is sensitive and requires recent authentication. Log in ' +
             'again before retrying this request.',
-        ["dependent-sdk-initialized-before-auth" /* DEPENDENT_SDK_INIT_BEFORE_AUTH */]: 'Another Firebase SDK was initialized and is trying to use Auth before Auth is ' +
+        ["dependent-sdk-initialized-before-auth" /* AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH */]: 'Another Firebase SDK was initialized and is trying to use Auth before Auth is ' +
             'initialized. Please be sure to call `initializeAuth` or `getAuth` before ' +
             'starting any other Firebase SDK.',
-        ["dynamic-link-not-activated" /* DYNAMIC_LINK_NOT_ACTIVATED */]: 'Please activate Dynamic Links in the Firebase Console and agree to the terms and ' +
+        ["dynamic-link-not-activated" /* AuthErrorCode.DYNAMIC_LINK_NOT_ACTIVATED */]: 'Please activate Dynamic Links in the Firebase Console and agree to the terms and ' +
             'conditions.',
-        ["email-change-needs-verification" /* EMAIL_CHANGE_NEEDS_VERIFICATION */]: 'Multi-factor users must always have a verified email.',
-        ["email-already-in-use" /* EMAIL_EXISTS */]: 'The email address is already in use by another account.',
-        ["emulator-config-failed" /* EMULATOR_CONFIG_FAILED */]: 'Auth instance has already been used to make a network call. Auth can ' +
+        ["email-change-needs-verification" /* AuthErrorCode.EMAIL_CHANGE_NEEDS_VERIFICATION */]: 'Multi-factor users must always have a verified email.',
+        ["email-already-in-use" /* AuthErrorCode.EMAIL_EXISTS */]: 'The email address is already in use by another account.',
+        ["emulator-config-failed" /* AuthErrorCode.EMULATOR_CONFIG_FAILED */]: 'Auth instance has already been used to make a network call. Auth can ' +
             'no longer be configured to use the emulator. Try calling ' +
             '"connectAuthEmulator()" sooner.',
-        ["expired-action-code" /* EXPIRED_OOB_CODE */]: 'The action code has expired.',
-        ["cancelled-popup-request" /* EXPIRED_POPUP_REQUEST */]: 'This operation has been cancelled due to another conflicting popup being opened.',
-        ["internal-error" /* INTERNAL_ERROR */]: 'An internal AuthError has occurred.',
-        ["invalid-app-credential" /* INVALID_APP_CREDENTIAL */]: 'The phone verification request contains an invalid application verifier.' +
+        ["expired-action-code" /* AuthErrorCode.EXPIRED_OOB_CODE */]: 'The action code has expired.',
+        ["cancelled-popup-request" /* AuthErrorCode.EXPIRED_POPUP_REQUEST */]: 'This operation has been cancelled due to another conflicting popup being opened.',
+        ["internal-error" /* AuthErrorCode.INTERNAL_ERROR */]: 'An internal AuthError has occurred.',
+        ["invalid-app-credential" /* AuthErrorCode.INVALID_APP_CREDENTIAL */]: 'The phone verification request contains an invalid application verifier.' +
             ' The reCAPTCHA token response is either invalid or expired.',
-        ["invalid-app-id" /* INVALID_APP_ID */]: 'The mobile app identifier is not registed for the current project.',
-        ["invalid-user-token" /* INVALID_AUTH */]: "This user's credential isn't valid for this project. This can happen " +
+        ["invalid-app-id" /* AuthErrorCode.INVALID_APP_ID */]: 'The mobile app identifier is not registed for the current project.',
+        ["invalid-user-token" /* AuthErrorCode.INVALID_AUTH */]: "This user's credential isn't valid for this project. This can happen " +
             "if the user's token has been tampered with, or if the user isn't for " +
             'the project associated with this API key.',
-        ["invalid-auth-event" /* INVALID_AUTH_EVENT */]: 'An internal AuthError has occurred.',
-        ["invalid-verification-code" /* INVALID_CODE */]: 'The SMS verification code used to create the phone auth credential is ' +
+        ["invalid-auth-event" /* AuthErrorCode.INVALID_AUTH_EVENT */]: 'An internal AuthError has occurred.',
+        ["invalid-verification-code" /* AuthErrorCode.INVALID_CODE */]: 'The SMS verification code used to create the phone auth credential is ' +
             'invalid. Please resend the verification code sms and be sure to use the ' +
             'verification code provided by the user.',
-        ["invalid-continue-uri" /* INVALID_CONTINUE_URI */]: 'The continue URL provided in the request is invalid.',
-        ["invalid-cordova-configuration" /* INVALID_CORDOVA_CONFIGURATION */]: 'The following Cordova plugins must be installed to enable OAuth sign-in: ' +
+        ["invalid-continue-uri" /* AuthErrorCode.INVALID_CONTINUE_URI */]: 'The continue URL provided in the request is invalid.',
+        ["invalid-cordova-configuration" /* AuthErrorCode.INVALID_CORDOVA_CONFIGURATION */]: 'The following Cordova plugins must be installed to enable OAuth sign-in: ' +
             'cordova-plugin-buildinfo, cordova-universal-links-plugin, ' +
             'cordova-plugin-browsertab, cordova-plugin-inappbrowser and ' +
             'cordova-plugin-customurlscheme.',
-        ["invalid-custom-token" /* INVALID_CUSTOM_TOKEN */]: 'The custom token format is incorrect. Please check the documentation.',
-        ["invalid-dynamic-link-domain" /* INVALID_DYNAMIC_LINK_DOMAIN */]: 'The provided dynamic link domain is not configured or authorized for the current project.',
-        ["invalid-email" /* INVALID_EMAIL */]: 'The email address is badly formatted.',
-        ["invalid-emulator-scheme" /* INVALID_EMULATOR_SCHEME */]: 'Emulator URL must start with a valid scheme (http:// or https://).',
-        ["invalid-api-key" /* INVALID_API_KEY */]: 'Your API key is invalid, please check you have copied it correctly.',
-        ["invalid-cert-hash" /* INVALID_CERT_HASH */]: 'The SHA-1 certificate hash provided is invalid.',
-        ["invalid-credential" /* INVALID_IDP_RESPONSE */]: 'The supplied auth credential is malformed or has expired.',
-        ["invalid-message-payload" /* INVALID_MESSAGE_PAYLOAD */]: 'The email template corresponding to this action contains invalid characters in its message. ' +
+        ["invalid-custom-token" /* AuthErrorCode.INVALID_CUSTOM_TOKEN */]: 'The custom token format is incorrect. Please check the documentation.',
+        ["invalid-dynamic-link-domain" /* AuthErrorCode.INVALID_DYNAMIC_LINK_DOMAIN */]: 'The provided dynamic link domain is not configured or authorized for the current project.',
+        ["invalid-email" /* AuthErrorCode.INVALID_EMAIL */]: 'The email address is badly formatted.',
+        ["invalid-emulator-scheme" /* AuthErrorCode.INVALID_EMULATOR_SCHEME */]: 'Emulator URL must start with a valid scheme (http:// or https://).',
+        ["invalid-api-key" /* AuthErrorCode.INVALID_API_KEY */]: 'Your API key is invalid, please check you have copied it correctly.',
+        ["invalid-cert-hash" /* AuthErrorCode.INVALID_CERT_HASH */]: 'The SHA-1 certificate hash provided is invalid.',
+        ["invalid-credential" /* AuthErrorCode.INVALID_IDP_RESPONSE */]: 'The supplied auth credential is malformed or has expired.',
+        ["invalid-message-payload" /* AuthErrorCode.INVALID_MESSAGE_PAYLOAD */]: 'The email template corresponding to this action contains invalid characters in its message. ' +
             'Please fix by going to the Auth email templates section in the Firebase Console.',
-        ["invalid-multi-factor-session" /* INVALID_MFA_SESSION */]: 'The request does not contain a valid proof of first factor successful sign-in.',
-        ["invalid-oauth-provider" /* INVALID_OAUTH_PROVIDER */]: 'EmailAuthProvider is not supported for this operation. This operation ' +
+        ["invalid-multi-factor-session" /* AuthErrorCode.INVALID_MFA_SESSION */]: 'The request does not contain a valid proof of first factor successful sign-in.',
+        ["invalid-oauth-provider" /* AuthErrorCode.INVALID_OAUTH_PROVIDER */]: 'EmailAuthProvider is not supported for this operation. This operation ' +
             'only supports OAuth providers.',
-        ["invalid-oauth-client-id" /* INVALID_OAUTH_CLIENT_ID */]: 'The OAuth client ID provided is either invalid or does not match the ' +
+        ["invalid-oauth-client-id" /* AuthErrorCode.INVALID_OAUTH_CLIENT_ID */]: 'The OAuth client ID provided is either invalid or does not match the ' +
             'specified API key.',
-        ["unauthorized-domain" /* INVALID_ORIGIN */]: 'This domain is not authorized for OAuth operations for your Firebase ' +
+        ["unauthorized-domain" /* AuthErrorCode.INVALID_ORIGIN */]: 'This domain is not authorized for OAuth operations for your Firebase ' +
             'project. Edit the list of authorized domains from the Firebase console.',
-        ["invalid-action-code" /* INVALID_OOB_CODE */]: 'The action code is invalid. This can happen if the code is malformed, ' +
+        ["invalid-action-code" /* AuthErrorCode.INVALID_OOB_CODE */]: 'The action code is invalid. This can happen if the code is malformed, ' +
             'expired, or has already been used.',
-        ["wrong-password" /* INVALID_PASSWORD */]: 'The password is invalid or the user does not have a password.',
-        ["invalid-persistence-type" /* INVALID_PERSISTENCE */]: 'The specified persistence type is invalid. It can only be local, session or none.',
-        ["invalid-phone-number" /* INVALID_PHONE_NUMBER */]: 'The format of the phone number provided is incorrect. Please enter the ' +
+        ["wrong-password" /* AuthErrorCode.INVALID_PASSWORD */]: 'The password is invalid or the user does not have a password.',
+        ["invalid-persistence-type" /* AuthErrorCode.INVALID_PERSISTENCE */]: 'The specified persistence type is invalid. It can only be local, session or none.',
+        ["invalid-phone-number" /* AuthErrorCode.INVALID_PHONE_NUMBER */]: 'The format of the phone number provided is incorrect. Please enter the ' +
             'phone number in a format that can be parsed into E.164 format. E.164 ' +
             'phone numbers are written in the format [+][country code][subscriber ' +
             'number including area code].',
-        ["invalid-provider-id" /* INVALID_PROVIDER_ID */]: 'The specified provider ID is invalid.',
-        ["invalid-recipient-email" /* INVALID_RECIPIENT_EMAIL */]: 'The email corresponding to this action failed to send as the provided ' +
+        ["invalid-provider-id" /* AuthErrorCode.INVALID_PROVIDER_ID */]: 'The specified provider ID is invalid.',
+        ["invalid-recipient-email" /* AuthErrorCode.INVALID_RECIPIENT_EMAIL */]: 'The email corresponding to this action failed to send as the provided ' +
             'recipient email address is invalid.',
-        ["invalid-sender" /* INVALID_SENDER */]: 'The email template corresponding to this action contains an invalid sender email or name. ' +
+        ["invalid-sender" /* AuthErrorCode.INVALID_SENDER */]: 'The email template corresponding to this action contains an invalid sender email or name. ' +
             'Please fix by going to the Auth email templates section in the Firebase Console.',
-        ["invalid-verification-id" /* INVALID_SESSION_INFO */]: 'The verification ID used to create the phone auth credential is invalid.',
-        ["invalid-tenant-id" /* INVALID_TENANT_ID */]: "The Auth instance's tenant ID is invalid.",
-        ["login-blocked" /* LOGIN_BLOCKED */]: 'Login blocked by user-provided method: {$originalMessage}',
-        ["missing-android-pkg-name" /* MISSING_ANDROID_PACKAGE_NAME */]: 'An Android Package Name must be provided if the Android App is required to be installed.',
-        ["auth-domain-config-required" /* MISSING_AUTH_DOMAIN */]: 'Be sure to include authDomain when calling firebase.initializeApp(), ' +
+        ["invalid-verification-id" /* AuthErrorCode.INVALID_SESSION_INFO */]: 'The verification ID used to create the phone auth credential is invalid.',
+        ["invalid-tenant-id" /* AuthErrorCode.INVALID_TENANT_ID */]: "The Auth instance's tenant ID is invalid.",
+        ["login-blocked" /* AuthErrorCode.LOGIN_BLOCKED */]: 'Login blocked by user-provided method: {$originalMessage}',
+        ["missing-android-pkg-name" /* AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME */]: 'An Android Package Name must be provided if the Android App is required to be installed.',
+        ["auth-domain-config-required" /* AuthErrorCode.MISSING_AUTH_DOMAIN */]: 'Be sure to include authDomain when calling firebase.initializeApp(), ' +
             'by following the instructions in the Firebase console.',
-        ["missing-app-credential" /* MISSING_APP_CREDENTIAL */]: 'The phone verification request is missing an application verifier ' +
+        ["missing-app-credential" /* AuthErrorCode.MISSING_APP_CREDENTIAL */]: 'The phone verification request is missing an application verifier ' +
             'assertion. A reCAPTCHA response token needs to be provided.',
-        ["missing-verification-code" /* MISSING_CODE */]: 'The phone auth credential was created with an empty SMS verification code.',
-        ["missing-continue-uri" /* MISSING_CONTINUE_URI */]: 'A continue URL must be provided in the request.',
-        ["missing-iframe-start" /* MISSING_IFRAME_START */]: 'An internal AuthError has occurred.',
-        ["missing-ios-bundle-id" /* MISSING_IOS_BUNDLE_ID */]: 'An iOS Bundle ID must be provided if an App Store ID is provided.',
-        ["missing-or-invalid-nonce" /* MISSING_OR_INVALID_NONCE */]: 'The request does not contain a valid nonce. This can occur if the ' +
+        ["missing-verification-code" /* AuthErrorCode.MISSING_CODE */]: 'The phone auth credential was created with an empty SMS verification code.',
+        ["missing-continue-uri" /* AuthErrorCode.MISSING_CONTINUE_URI */]: 'A continue URL must be provided in the request.',
+        ["missing-iframe-start" /* AuthErrorCode.MISSING_IFRAME_START */]: 'An internal AuthError has occurred.',
+        ["missing-ios-bundle-id" /* AuthErrorCode.MISSING_IOS_BUNDLE_ID */]: 'An iOS Bundle ID must be provided if an App Store ID is provided.',
+        ["missing-or-invalid-nonce" /* AuthErrorCode.MISSING_OR_INVALID_NONCE */]: 'The request does not contain a valid nonce. This can occur if the ' +
             'SHA-256 hash of the provided raw nonce does not match the hashed nonce ' +
             'in the ID token payload.',
-        ["missing-multi-factor-info" /* MISSING_MFA_INFO */]: 'No second factor identifier is provided.',
-        ["missing-multi-factor-session" /* MISSING_MFA_SESSION */]: 'The request is missing proof of first factor successful sign-in.',
-        ["missing-phone-number" /* MISSING_PHONE_NUMBER */]: 'To send verification codes, provide a phone number for the recipient.',
-        ["missing-verification-id" /* MISSING_SESSION_INFO */]: 'The phone auth credential was created with an empty verification ID.',
-        ["app-deleted" /* MODULE_DESTROYED */]: 'This instance of FirebaseApp has been deleted.',
-        ["multi-factor-info-not-found" /* MFA_INFO_NOT_FOUND */]: 'The user does not have a second factor matching the identifier provided.',
-        ["multi-factor-auth-required" /* MFA_REQUIRED */]: 'Proof of ownership of a second factor is required to complete sign-in.',
-        ["account-exists-with-different-credential" /* NEED_CONFIRMATION */]: 'An account already exists with the same email address but different ' +
+        ["missing-multi-factor-info" /* AuthErrorCode.MISSING_MFA_INFO */]: 'No second factor identifier is provided.',
+        ["missing-multi-factor-session" /* AuthErrorCode.MISSING_MFA_SESSION */]: 'The request is missing proof of first factor successful sign-in.',
+        ["missing-phone-number" /* AuthErrorCode.MISSING_PHONE_NUMBER */]: 'To send verification codes, provide a phone number for the recipient.',
+        ["missing-verification-id" /* AuthErrorCode.MISSING_SESSION_INFO */]: 'The phone auth credential was created with an empty verification ID.',
+        ["app-deleted" /* AuthErrorCode.MODULE_DESTROYED */]: 'This instance of FirebaseApp has been deleted.',
+        ["multi-factor-info-not-found" /* AuthErrorCode.MFA_INFO_NOT_FOUND */]: 'The user does not have a second factor matching the identifier provided.',
+        ["multi-factor-auth-required" /* AuthErrorCode.MFA_REQUIRED */]: 'Proof of ownership of a second factor is required to complete sign-in.',
+        ["account-exists-with-different-credential" /* AuthErrorCode.NEED_CONFIRMATION */]: 'An account already exists with the same email address but different ' +
             'sign-in credentials. Sign in using a provider associated with this ' +
             'email address.',
-        ["network-request-failed" /* NETWORK_REQUEST_FAILED */]: 'A network AuthError (such as timeout, interrupted connection or unreachable host) has occurred.',
-        ["no-auth-event" /* NO_AUTH_EVENT */]: 'An internal AuthError has occurred.',
-        ["no-such-provider" /* NO_SUCH_PROVIDER */]: 'User was not linked to an account with the given provider.',
-        ["null-user" /* NULL_USER */]: 'A null user object was provided as the argument for an operation which ' +
+        ["network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */]: 'A network AuthError (such as timeout, interrupted connection or unreachable host) has occurred.',
+        ["no-auth-event" /* AuthErrorCode.NO_AUTH_EVENT */]: 'An internal AuthError has occurred.',
+        ["no-such-provider" /* AuthErrorCode.NO_SUCH_PROVIDER */]: 'User was not linked to an account with the given provider.',
+        ["null-user" /* AuthErrorCode.NULL_USER */]: 'A null user object was provided as the argument for an operation which ' +
             'requires a non-null user object.',
-        ["operation-not-allowed" /* OPERATION_NOT_ALLOWED */]: 'The given sign-in provider is disabled for this Firebase project. ' +
+        ["operation-not-allowed" /* AuthErrorCode.OPERATION_NOT_ALLOWED */]: 'The given sign-in provider is disabled for this Firebase project. ' +
             'Enable it in the Firebase console, under the sign-in method tab of the ' +
             'Auth section.',
-        ["operation-not-supported-in-this-environment" /* OPERATION_NOT_SUPPORTED */]: 'This operation is not supported in the environment this application is ' +
+        ["operation-not-supported-in-this-environment" /* AuthErrorCode.OPERATION_NOT_SUPPORTED */]: 'This operation is not supported in the environment this application is ' +
             'running on. "location.protocol" must be http, https or chrome-extension' +
             ' and web storage must be enabled.',
-        ["popup-blocked" /* POPUP_BLOCKED */]: 'Unable to establish a connection with the popup. It may have been blocked by the browser.',
-        ["popup-closed-by-user" /* POPUP_CLOSED_BY_USER */]: 'The popup has been closed by the user before finalizing the operation.',
-        ["provider-already-linked" /* PROVIDER_ALREADY_LINKED */]: 'User can only be linked to one identity for the given provider.',
-        ["quota-exceeded" /* QUOTA_EXCEEDED */]: "The project's quota for this operation has been exceeded.",
-        ["redirect-cancelled-by-user" /* REDIRECT_CANCELLED_BY_USER */]: 'The redirect operation has been cancelled by the user before finalizing.',
-        ["redirect-operation-pending" /* REDIRECT_OPERATION_PENDING */]: 'A redirect sign-in operation is already pending.',
-        ["rejected-credential" /* REJECTED_CREDENTIAL */]: 'The request contains malformed or mismatching credentials.',
-        ["second-factor-already-in-use" /* SECOND_FACTOR_ALREADY_ENROLLED */]: 'The second factor is already enrolled on this account.',
-        ["maximum-second-factor-count-exceeded" /* SECOND_FACTOR_LIMIT_EXCEEDED */]: 'The maximum allowed number of second factors on a user has been exceeded.',
-        ["tenant-id-mismatch" /* TENANT_ID_MISMATCH */]: "The provided tenant ID does not match the Auth instance's tenant ID",
-        ["timeout" /* TIMEOUT */]: 'The operation has timed out.',
-        ["user-token-expired" /* TOKEN_EXPIRED */]: "The user's credential is no longer valid. The user must sign in again.",
-        ["too-many-requests" /* TOO_MANY_ATTEMPTS_TRY_LATER */]: 'We have blocked all requests from this device due to unusual activity. ' +
+        ["popup-blocked" /* AuthErrorCode.POPUP_BLOCKED */]: 'Unable to establish a connection with the popup. It may have been blocked by the browser.',
+        ["popup-closed-by-user" /* AuthErrorCode.POPUP_CLOSED_BY_USER */]: 'The popup has been closed by the user before finalizing the operation.',
+        ["provider-already-linked" /* AuthErrorCode.PROVIDER_ALREADY_LINKED */]: 'User can only be linked to one identity for the given provider.',
+        ["quota-exceeded" /* AuthErrorCode.QUOTA_EXCEEDED */]: "The project's quota for this operation has been exceeded.",
+        ["redirect-cancelled-by-user" /* AuthErrorCode.REDIRECT_CANCELLED_BY_USER */]: 'The redirect operation has been cancelled by the user before finalizing.',
+        ["redirect-operation-pending" /* AuthErrorCode.REDIRECT_OPERATION_PENDING */]: 'A redirect sign-in operation is already pending.',
+        ["rejected-credential" /* AuthErrorCode.REJECTED_CREDENTIAL */]: 'The request contains malformed or mismatching credentials.',
+        ["second-factor-already-in-use" /* AuthErrorCode.SECOND_FACTOR_ALREADY_ENROLLED */]: 'The second factor is already enrolled on this account.',
+        ["maximum-second-factor-count-exceeded" /* AuthErrorCode.SECOND_FACTOR_LIMIT_EXCEEDED */]: 'The maximum allowed number of second factors on a user has been exceeded.',
+        ["tenant-id-mismatch" /* AuthErrorCode.TENANT_ID_MISMATCH */]: "The provided tenant ID does not match the Auth instance's tenant ID",
+        ["timeout" /* AuthErrorCode.TIMEOUT */]: 'The operation has timed out.',
+        ["user-token-expired" /* AuthErrorCode.TOKEN_EXPIRED */]: "The user's credential is no longer valid. The user must sign in again.",
+        ["too-many-requests" /* AuthErrorCode.TOO_MANY_ATTEMPTS_TRY_LATER */]: 'We have blocked all requests from this device due to unusual activity. ' +
             'Try again later.',
-        ["unauthorized-continue-uri" /* UNAUTHORIZED_DOMAIN */]: 'The domain of the continue URL is not whitelisted.  Please whitelist ' +
+        ["unauthorized-continue-uri" /* AuthErrorCode.UNAUTHORIZED_DOMAIN */]: 'The domain of the continue URL is not whitelisted.  Please whitelist ' +
             'the domain in the Firebase console.',
-        ["unsupported-first-factor" /* UNSUPPORTED_FIRST_FACTOR */]: 'Enrolling a second factor or signing in with a multi-factor account requires sign-in with a supported first factor.',
-        ["unsupported-persistence-type" /* UNSUPPORTED_PERSISTENCE */]: 'The current environment does not support the specified persistence type.',
-        ["unsupported-tenant-operation" /* UNSUPPORTED_TENANT_OPERATION */]: 'This operation is not supported in a multi-tenant context.',
-        ["unverified-email" /* UNVERIFIED_EMAIL */]: 'The operation requires a verified email.',
-        ["user-cancelled" /* USER_CANCELLED */]: 'The user did not grant your application the permissions it requested.',
-        ["user-not-found" /* USER_DELETED */]: 'There is no user record corresponding to this identifier. The user may ' +
+        ["unsupported-first-factor" /* AuthErrorCode.UNSUPPORTED_FIRST_FACTOR */]: 'Enrolling a second factor or signing in with a multi-factor account requires sign-in with a supported first factor.',
+        ["unsupported-persistence-type" /* AuthErrorCode.UNSUPPORTED_PERSISTENCE */]: 'The current environment does not support the specified persistence type.',
+        ["unsupported-tenant-operation" /* AuthErrorCode.UNSUPPORTED_TENANT_OPERATION */]: 'This operation is not supported in a multi-tenant context.',
+        ["unverified-email" /* AuthErrorCode.UNVERIFIED_EMAIL */]: 'The operation requires a verified email.',
+        ["user-cancelled" /* AuthErrorCode.USER_CANCELLED */]: 'The user did not grant your application the permissions it requested.',
+        ["user-not-found" /* AuthErrorCode.USER_DELETED */]: 'There is no user record corresponding to this identifier. The user may ' +
             'have been deleted.',
-        ["user-disabled" /* USER_DISABLED */]: 'The user account has been disabled by an administrator.',
-        ["user-mismatch" /* USER_MISMATCH */]: 'The supplied credentials do not correspond to the previously signed in user.',
-        ["user-signed-out" /* USER_SIGNED_OUT */]: '',
-        ["weak-password" /* WEAK_PASSWORD */]: 'The password must be 6 characters long or more.',
-        ["web-storage-unsupported" /* WEB_STORAGE_UNSUPPORTED */]: 'This browser is not supported or 3rd party cookies and data may be disabled.',
-        ["already-initialized" /* ALREADY_INITIALIZED */]: 'initializeAuth() has already been called with ' +
+        ["user-disabled" /* AuthErrorCode.USER_DISABLED */]: 'The user account has been disabled by an administrator.',
+        ["user-mismatch" /* AuthErrorCode.USER_MISMATCH */]: 'The supplied credentials do not correspond to the previously signed in user.',
+        ["user-signed-out" /* AuthErrorCode.USER_SIGNED_OUT */]: '',
+        ["weak-password" /* AuthErrorCode.WEAK_PASSWORD */]: 'The password must be 6 characters long or more.',
+        ["web-storage-unsupported" /* AuthErrorCode.WEB_STORAGE_UNSUPPORTED */]: 'This browser is not supported or 3rd party cookies and data may be disabled.',
+        ["already-initialized" /* AuthErrorCode.ALREADY_INITIALIZED */]: 'initializeAuth() has already been called with ' +
             'different options. To avoid this error, call initializeAuth() with the ' +
             'same options as when it was originally called, or call getAuth() to return the' +
             ' already initialized instance.'
@@ -271,7 +271,7 @@ function _prodErrorMap() {
     // nature of this error, developers will never be able to see the message
     // using the debugErrorMap (which is installed during auth initialization).
     return {
-        ["dependent-sdk-initialized-before-auth" /* DEPENDENT_SDK_INIT_BEFORE_AUTH */]: 'Another Firebase SDK was initialized and is trying to use Auth before Auth is ' +
+        ["dependent-sdk-initialized-before-auth" /* AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH */]: 'Another Firebase SDK was initialized and is trying to use Auth before Auth is ' +
             'initialized. Please be sure to call `initializeAuth` or `getAuth` before ' +
             'starting any other Firebase SDK.'
     };
@@ -458,9 +458,9 @@ function _assertInstanceOf(auth, object, instance) {
     const constructorInstance = instance;
     if (!(object instanceof constructorInstance)) {
         if (constructorInstance.name !== object.constructor.name) {
-            _fail(auth, "argument-error" /* ARGUMENT_ERROR */);
+            _fail(auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
         }
-        throw _errorWithCustomMessage(auth, "argument-error" /* ARGUMENT_ERROR */, `Type of ${object.constructor.name} does not match expected instance.` +
+        throw _errorWithCustomMessage(auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */, `Type of ${object.constructor.name} does not match expected instance.` +
             `Did you pass a reference from a different Auth SDK?`);
     }
 }
@@ -588,7 +588,7 @@ function initializeAuth(app, deps) {
             return auth;
         }
         else {
-            _fail(auth, "already-initialized" /* ALREADY_INITIALIZED */);
+            _fail(auth, "already-initialized" /* AuthErrorCode.ALREADY_INITIALIZED */);
         }
     }
     const auth = provider.initialize({ options: deps });
@@ -716,7 +716,7 @@ class Delay {
     get() {
         if (!_isOnline()) {
             // Pick the shorter timeout.
-            return Math.min(5000 /* OFFLINE */, this.shortDelay);
+            return Math.min(5000 /* DelayMin.OFFLINE */, this.shortDelay);
         }
         // If running in a mobile environment, return the long delay, otherwise
         // return the short delay.
@@ -827,64 +827,64 @@ class FetchProvider {
  */
 const SERVER_ERROR_MAP = {
     // Custom token errors.
-    ["CREDENTIAL_MISMATCH" /* CREDENTIAL_MISMATCH */]: "custom-token-mismatch" /* CREDENTIAL_MISMATCH */,
+    ["CREDENTIAL_MISMATCH" /* ServerError.CREDENTIAL_MISMATCH */]: "custom-token-mismatch" /* AuthErrorCode.CREDENTIAL_MISMATCH */,
     // This can only happen if the SDK sends a bad request.
-    ["MISSING_CUSTOM_TOKEN" /* MISSING_CUSTOM_TOKEN */]: "internal-error" /* INTERNAL_ERROR */,
+    ["MISSING_CUSTOM_TOKEN" /* ServerError.MISSING_CUSTOM_TOKEN */]: "internal-error" /* AuthErrorCode.INTERNAL_ERROR */,
     // Create Auth URI errors.
-    ["INVALID_IDENTIFIER" /* INVALID_IDENTIFIER */]: "invalid-email" /* INVALID_EMAIL */,
+    ["INVALID_IDENTIFIER" /* ServerError.INVALID_IDENTIFIER */]: "invalid-email" /* AuthErrorCode.INVALID_EMAIL */,
     // This can only happen if the SDK sends a bad request.
-    ["MISSING_CONTINUE_URI" /* MISSING_CONTINUE_URI */]: "internal-error" /* INTERNAL_ERROR */,
+    ["MISSING_CONTINUE_URI" /* ServerError.MISSING_CONTINUE_URI */]: "internal-error" /* AuthErrorCode.INTERNAL_ERROR */,
     // Sign in with email and password errors (some apply to sign up too).
-    ["INVALID_PASSWORD" /* INVALID_PASSWORD */]: "wrong-password" /* INVALID_PASSWORD */,
+    ["INVALID_PASSWORD" /* ServerError.INVALID_PASSWORD */]: "wrong-password" /* AuthErrorCode.INVALID_PASSWORD */,
     // This can only happen if the SDK sends a bad request.
-    ["MISSING_PASSWORD" /* MISSING_PASSWORD */]: "internal-error" /* INTERNAL_ERROR */,
+    ["MISSING_PASSWORD" /* ServerError.MISSING_PASSWORD */]: "internal-error" /* AuthErrorCode.INTERNAL_ERROR */,
     // Sign up with email and password errors.
-    ["EMAIL_EXISTS" /* EMAIL_EXISTS */]: "email-already-in-use" /* EMAIL_EXISTS */,
-    ["PASSWORD_LOGIN_DISABLED" /* PASSWORD_LOGIN_DISABLED */]: "operation-not-allowed" /* OPERATION_NOT_ALLOWED */,
+    ["EMAIL_EXISTS" /* ServerError.EMAIL_EXISTS */]: "email-already-in-use" /* AuthErrorCode.EMAIL_EXISTS */,
+    ["PASSWORD_LOGIN_DISABLED" /* ServerError.PASSWORD_LOGIN_DISABLED */]: "operation-not-allowed" /* AuthErrorCode.OPERATION_NOT_ALLOWED */,
     // Verify assertion for sign in with credential errors:
-    ["INVALID_IDP_RESPONSE" /* INVALID_IDP_RESPONSE */]: "invalid-credential" /* INVALID_IDP_RESPONSE */,
-    ["INVALID_PENDING_TOKEN" /* INVALID_PENDING_TOKEN */]: "invalid-credential" /* INVALID_IDP_RESPONSE */,
-    ["FEDERATED_USER_ID_ALREADY_LINKED" /* FEDERATED_USER_ID_ALREADY_LINKED */]: "credential-already-in-use" /* CREDENTIAL_ALREADY_IN_USE */,
+    ["INVALID_IDP_RESPONSE" /* ServerError.INVALID_IDP_RESPONSE */]: "invalid-credential" /* AuthErrorCode.INVALID_IDP_RESPONSE */,
+    ["INVALID_PENDING_TOKEN" /* ServerError.INVALID_PENDING_TOKEN */]: "invalid-credential" /* AuthErrorCode.INVALID_IDP_RESPONSE */,
+    ["FEDERATED_USER_ID_ALREADY_LINKED" /* ServerError.FEDERATED_USER_ID_ALREADY_LINKED */]: "credential-already-in-use" /* AuthErrorCode.CREDENTIAL_ALREADY_IN_USE */,
     // This can only happen if the SDK sends a bad request.
-    ["MISSING_REQ_TYPE" /* MISSING_REQ_TYPE */]: "internal-error" /* INTERNAL_ERROR */,
+    ["MISSING_REQ_TYPE" /* ServerError.MISSING_REQ_TYPE */]: "internal-error" /* AuthErrorCode.INTERNAL_ERROR */,
     // Send Password reset email errors:
-    ["EMAIL_NOT_FOUND" /* EMAIL_NOT_FOUND */]: "user-not-found" /* USER_DELETED */,
-    ["RESET_PASSWORD_EXCEED_LIMIT" /* RESET_PASSWORD_EXCEED_LIMIT */]: "too-many-requests" /* TOO_MANY_ATTEMPTS_TRY_LATER */,
-    ["EXPIRED_OOB_CODE" /* EXPIRED_OOB_CODE */]: "expired-action-code" /* EXPIRED_OOB_CODE */,
-    ["INVALID_OOB_CODE" /* INVALID_OOB_CODE */]: "invalid-action-code" /* INVALID_OOB_CODE */,
+    ["EMAIL_NOT_FOUND" /* ServerError.EMAIL_NOT_FOUND */]: "user-not-found" /* AuthErrorCode.USER_DELETED */,
+    ["RESET_PASSWORD_EXCEED_LIMIT" /* ServerError.RESET_PASSWORD_EXCEED_LIMIT */]: "too-many-requests" /* AuthErrorCode.TOO_MANY_ATTEMPTS_TRY_LATER */,
+    ["EXPIRED_OOB_CODE" /* ServerError.EXPIRED_OOB_CODE */]: "expired-action-code" /* AuthErrorCode.EXPIRED_OOB_CODE */,
+    ["INVALID_OOB_CODE" /* ServerError.INVALID_OOB_CODE */]: "invalid-action-code" /* AuthErrorCode.INVALID_OOB_CODE */,
     // This can only happen if the SDK sends a bad request.
-    ["MISSING_OOB_CODE" /* MISSING_OOB_CODE */]: "internal-error" /* INTERNAL_ERROR */,
+    ["MISSING_OOB_CODE" /* ServerError.MISSING_OOB_CODE */]: "internal-error" /* AuthErrorCode.INTERNAL_ERROR */,
     // Operations that require ID token in request:
-    ["CREDENTIAL_TOO_OLD_LOGIN_AGAIN" /* CREDENTIAL_TOO_OLD_LOGIN_AGAIN */]: "requires-recent-login" /* CREDENTIAL_TOO_OLD_LOGIN_AGAIN */,
-    ["INVALID_ID_TOKEN" /* INVALID_ID_TOKEN */]: "invalid-user-token" /* INVALID_AUTH */,
-    ["TOKEN_EXPIRED" /* TOKEN_EXPIRED */]: "user-token-expired" /* TOKEN_EXPIRED */,
-    ["USER_NOT_FOUND" /* USER_NOT_FOUND */]: "user-token-expired" /* TOKEN_EXPIRED */,
+    ["CREDENTIAL_TOO_OLD_LOGIN_AGAIN" /* ServerError.CREDENTIAL_TOO_OLD_LOGIN_AGAIN */]: "requires-recent-login" /* AuthErrorCode.CREDENTIAL_TOO_OLD_LOGIN_AGAIN */,
+    ["INVALID_ID_TOKEN" /* ServerError.INVALID_ID_TOKEN */]: "invalid-user-token" /* AuthErrorCode.INVALID_AUTH */,
+    ["TOKEN_EXPIRED" /* ServerError.TOKEN_EXPIRED */]: "user-token-expired" /* AuthErrorCode.TOKEN_EXPIRED */,
+    ["USER_NOT_FOUND" /* ServerError.USER_NOT_FOUND */]: "user-token-expired" /* AuthErrorCode.TOKEN_EXPIRED */,
     // Other errors.
-    ["TOO_MANY_ATTEMPTS_TRY_LATER" /* TOO_MANY_ATTEMPTS_TRY_LATER */]: "too-many-requests" /* TOO_MANY_ATTEMPTS_TRY_LATER */,
+    ["TOO_MANY_ATTEMPTS_TRY_LATER" /* ServerError.TOO_MANY_ATTEMPTS_TRY_LATER */]: "too-many-requests" /* AuthErrorCode.TOO_MANY_ATTEMPTS_TRY_LATER */,
     // Phone Auth related errors.
-    ["INVALID_CODE" /* INVALID_CODE */]: "invalid-verification-code" /* INVALID_CODE */,
-    ["INVALID_SESSION_INFO" /* INVALID_SESSION_INFO */]: "invalid-verification-id" /* INVALID_SESSION_INFO */,
-    ["INVALID_TEMPORARY_PROOF" /* INVALID_TEMPORARY_PROOF */]: "invalid-credential" /* INVALID_IDP_RESPONSE */,
-    ["MISSING_SESSION_INFO" /* MISSING_SESSION_INFO */]: "missing-verification-id" /* MISSING_SESSION_INFO */,
-    ["SESSION_EXPIRED" /* SESSION_EXPIRED */]: "code-expired" /* CODE_EXPIRED */,
+    ["INVALID_CODE" /* ServerError.INVALID_CODE */]: "invalid-verification-code" /* AuthErrorCode.INVALID_CODE */,
+    ["INVALID_SESSION_INFO" /* ServerError.INVALID_SESSION_INFO */]: "invalid-verification-id" /* AuthErrorCode.INVALID_SESSION_INFO */,
+    ["INVALID_TEMPORARY_PROOF" /* ServerError.INVALID_TEMPORARY_PROOF */]: "invalid-credential" /* AuthErrorCode.INVALID_IDP_RESPONSE */,
+    ["MISSING_SESSION_INFO" /* ServerError.MISSING_SESSION_INFO */]: "missing-verification-id" /* AuthErrorCode.MISSING_SESSION_INFO */,
+    ["SESSION_EXPIRED" /* ServerError.SESSION_EXPIRED */]: "code-expired" /* AuthErrorCode.CODE_EXPIRED */,
     // Other action code errors when additional settings passed.
     // MISSING_CONTINUE_URI is getting mapped to INTERNAL_ERROR above.
     // This is OK as this error will be caught by client side validation.
-    ["MISSING_ANDROID_PACKAGE_NAME" /* MISSING_ANDROID_PACKAGE_NAME */]: "missing-android-pkg-name" /* MISSING_ANDROID_PACKAGE_NAME */,
-    ["UNAUTHORIZED_DOMAIN" /* UNAUTHORIZED_DOMAIN */]: "unauthorized-continue-uri" /* UNAUTHORIZED_DOMAIN */,
+    ["MISSING_ANDROID_PACKAGE_NAME" /* ServerError.MISSING_ANDROID_PACKAGE_NAME */]: "missing-android-pkg-name" /* AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME */,
+    ["UNAUTHORIZED_DOMAIN" /* ServerError.UNAUTHORIZED_DOMAIN */]: "unauthorized-continue-uri" /* AuthErrorCode.UNAUTHORIZED_DOMAIN */,
     // getProjectConfig errors when clientId is passed.
-    ["INVALID_OAUTH_CLIENT_ID" /* INVALID_OAUTH_CLIENT_ID */]: "invalid-oauth-client-id" /* INVALID_OAUTH_CLIENT_ID */,
+    ["INVALID_OAUTH_CLIENT_ID" /* ServerError.INVALID_OAUTH_CLIENT_ID */]: "invalid-oauth-client-id" /* AuthErrorCode.INVALID_OAUTH_CLIENT_ID */,
     // User actions (sign-up or deletion) disabled errors.
-    ["ADMIN_ONLY_OPERATION" /* ADMIN_ONLY_OPERATION */]: "admin-restricted-operation" /* ADMIN_ONLY_OPERATION */,
+    ["ADMIN_ONLY_OPERATION" /* ServerError.ADMIN_ONLY_OPERATION */]: "admin-restricted-operation" /* AuthErrorCode.ADMIN_ONLY_OPERATION */,
     // Multi factor related errors.
-    ["INVALID_MFA_PENDING_CREDENTIAL" /* INVALID_MFA_PENDING_CREDENTIAL */]: "invalid-multi-factor-session" /* INVALID_MFA_SESSION */,
-    ["MFA_ENROLLMENT_NOT_FOUND" /* MFA_ENROLLMENT_NOT_FOUND */]: "multi-factor-info-not-found" /* MFA_INFO_NOT_FOUND */,
-    ["MISSING_MFA_ENROLLMENT_ID" /* MISSING_MFA_ENROLLMENT_ID */]: "missing-multi-factor-info" /* MISSING_MFA_INFO */,
-    ["MISSING_MFA_PENDING_CREDENTIAL" /* MISSING_MFA_PENDING_CREDENTIAL */]: "missing-multi-factor-session" /* MISSING_MFA_SESSION */,
-    ["SECOND_FACTOR_EXISTS" /* SECOND_FACTOR_EXISTS */]: "second-factor-already-in-use" /* SECOND_FACTOR_ALREADY_ENROLLED */,
-    ["SECOND_FACTOR_LIMIT_EXCEEDED" /* SECOND_FACTOR_LIMIT_EXCEEDED */]: "maximum-second-factor-count-exceeded" /* SECOND_FACTOR_LIMIT_EXCEEDED */,
+    ["INVALID_MFA_PENDING_CREDENTIAL" /* ServerError.INVALID_MFA_PENDING_CREDENTIAL */]: "invalid-multi-factor-session" /* AuthErrorCode.INVALID_MFA_SESSION */,
+    ["MFA_ENROLLMENT_NOT_FOUND" /* ServerError.MFA_ENROLLMENT_NOT_FOUND */]: "multi-factor-info-not-found" /* AuthErrorCode.MFA_INFO_NOT_FOUND */,
+    ["MISSING_MFA_ENROLLMENT_ID" /* ServerError.MISSING_MFA_ENROLLMENT_ID */]: "missing-multi-factor-info" /* AuthErrorCode.MISSING_MFA_INFO */,
+    ["MISSING_MFA_PENDING_CREDENTIAL" /* ServerError.MISSING_MFA_PENDING_CREDENTIAL */]: "missing-multi-factor-session" /* AuthErrorCode.MISSING_MFA_SESSION */,
+    ["SECOND_FACTOR_EXISTS" /* ServerError.SECOND_FACTOR_EXISTS */]: "second-factor-already-in-use" /* AuthErrorCode.SECOND_FACTOR_ALREADY_ENROLLED */,
+    ["SECOND_FACTOR_LIMIT_EXCEEDED" /* ServerError.SECOND_FACTOR_LIMIT_EXCEEDED */]: "maximum-second-factor-count-exceeded" /* AuthErrorCode.SECOND_FACTOR_LIMIT_EXCEEDED */,
     // Blocking functions related errors.
-    ["BLOCKING_FUNCTION_ERROR_RESPONSE" /* BLOCKING_FUNCTION_ERROR_RESPONSE */]: "internal-error" /* INTERNAL_ERROR */
+    ["BLOCKING_FUNCTION_ERROR_RESPONSE" /* ServerError.BLOCKING_FUNCTION_ERROR_RESPONSE */]: "internal-error" /* AuthErrorCode.INTERNAL_ERROR */
 };
 
 /**
@@ -915,7 +915,7 @@ async function _performApiRequest(auth, method, path, request, customErrorMap =
         let body = {};
         let params = {};
         if (request) {
-            if (method === "GET" /* GET */) {
+            if (method === "GET" /* HttpMethod.GET */) {
                 params = request;
             }
             else {
@@ -926,9 +926,9 @@ async function _performApiRequest(auth, method, path, request, customErrorMap =
         }
         const query = querystring(Object.assign({ key: auth.config.apiKey }, params)).slice(1);
         const headers = await auth._getAdditionalHeaders();
-        headers["Content-Type" /* CONTENT_TYPE */] = 'application/json';
+        headers["Content-Type" /* HttpHeader.CONTENT_TYPE */] = 'application/json';
         if (auth.languageCode) {
-            headers["X-Firebase-Locale" /* X_FIREBASE_LOCALE */] = auth.languageCode;
+            headers["X-Firebase-Locale" /* HttpHeader.X_FIREBASE_LOCALE */] = auth.languageCode;
         }
         return FetchProvider.fetch()(_getFinalTarget(auth, auth.config.apiHost, path, query), Object.assign({ method,
             headers, referrerPolicy: 'no-referrer' }, body));
@@ -948,7 +948,7 @@ async function _performFetchWithErrorHandling(auth, customErrorMap, fetchFn) {
         networkTimeout.clearNetworkTimeout();
         const json = await response.json();
         if ('needConfirmation' in json) {
-            throw _makeTaggedError(auth, "account-exists-with-different-credential" /* NEED_CONFIRMATION */, json);
+            throw _makeTaggedError(auth, "account-exists-with-different-credential" /* AuthErrorCode.NEED_CONFIRMATION */, json);
         }
         if (response.ok && !('errorMessage' in json)) {
             return json;
@@ -956,14 +956,14 @@ async function _performFetchWithErrorHandling(auth, customErrorMap, fetchFn) {
         else {
             const errorMessage = response.ok ? json.errorMessage : json.error.message;
             const [serverErrorCode, serverErrorMessage] = errorMessage.split(' : ');
-            if (serverErrorCode === "FEDERATED_USER_ID_ALREADY_LINKED" /* FEDERATED_USER_ID_ALREADY_LINKED */) {
-                throw _makeTaggedError(auth, "credential-already-in-use" /* CREDENTIAL_ALREADY_IN_USE */, json);
+            if (serverErrorCode === "FEDERATED_USER_ID_ALREADY_LINKED" /* ServerError.FEDERATED_USER_ID_ALREADY_LINKED */) {
+                throw _makeTaggedError(auth, "credential-already-in-use" /* AuthErrorCode.CREDENTIAL_ALREADY_IN_USE */, json);
             }
-            else if (serverErrorCode === "EMAIL_EXISTS" /* EMAIL_EXISTS */) {
-                throw _makeTaggedError(auth, "email-already-in-use" /* EMAIL_EXISTS */, json);
+            else if (serverErrorCode === "EMAIL_EXISTS" /* ServerError.EMAIL_EXISTS */) {
+                throw _makeTaggedError(auth, "email-already-in-use" /* AuthErrorCode.EMAIL_EXISTS */, json);
             }
-            else if (serverErrorCode === "USER_DISABLED" /* USER_DISABLED */) {
-                throw _makeTaggedError(auth, "user-disabled" /* USER_DISABLED */, json);
+            else if (serverErrorCode === "USER_DISABLED" /* ServerError.USER_DISABLED */) {
+                throw _makeTaggedError(auth, "user-disabled" /* AuthErrorCode.USER_DISABLED */, json);
             }
             const authError = errorMap[serverErrorCode] ||
                 serverErrorCode
@@ -981,13 +981,13 @@ async function _performFetchWithErrorHandling(auth, customErrorMap, fetchFn) {
         if (e instanceof FirebaseError) {
             throw e;
         }
-        _fail(auth, "network-request-failed" /* NETWORK_REQUEST_FAILED */);
+        _fail(auth, "network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */);
     }
 }
 async function _performSignInRequest(auth, method, path, request, customErrorMap = {}) {
     const serverResponse = (await _performApiRequest(auth, method, path, request, customErrorMap));
     if ('mfaPendingCredential' in serverResponse) {
-        _fail(auth, "multi-factor-auth-required" /* MFA_REQUIRED */, {
+        _fail(auth, "multi-factor-auth-required" /* AuthErrorCode.MFA_REQUIRED */, {
             _serverResponse: serverResponse
         });
     }
@@ -1009,7 +1009,7 @@ class NetworkTimeout {
         this.timer = null;
         this.promise = new Promise((_, reject) => {
             this.timer = setTimeout(() => {
-                return reject(_createError(this.auth, "network-request-failed" /* NETWORK_REQUEST_FAILED */));
+                return reject(_createError(this.auth, "network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */));
             }, DEFAULT_API_TIMEOUT_MS.get());
         });
     }
@@ -1050,13 +1050,13 @@ function _makeTaggedError(auth, code, response) {
  * limitations under the License.
  */
 async function deleteAccount(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v1/accounts:delete" /* DELETE_ACCOUNT */, request);
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:delete" /* Endpoint.DELETE_ACCOUNT */, request);
 }
 async function deleteLinkedAccounts(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v1/accounts:update" /* SET_ACCOUNT_INFO */, request);
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:update" /* Endpoint.SET_ACCOUNT_INFO */, request);
 }
 async function getAccountInfo(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v1/accounts:lookup" /* GET_ACCOUNT_INFO */, request);
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:lookup" /* Endpoint.GET_ACCOUNT_INFO */, request);
 }
 
 /**
@@ -1141,7 +1141,7 @@ async function getIdTokenResult(user, forceRefresh = false) {
     const userInternal = getModularInstance(user);
     const token = await userInternal.getIdToken(forceRefresh);
     const claims = _parseToken(token);
-    _assert(claims && claims.exp && claims.auth_time && claims.iat, userInternal.auth, "internal-error" /* INTERNAL_ERROR */);
+    _assert(claims && claims.exp && claims.auth_time && claims.iat, userInternal.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
     const firebase = typeof claims.firebase === 'object' ? claims.firebase : undefined;
     const signInProvider = firebase === null || firebase === void 0 ? void 0 : firebase['sign_in_provider'];
     return {
@@ -1158,7 +1158,6 @@ function secondsStringToMilliseconds(seconds) {
     return Number(seconds) * 1000;
 }
 function _parseToken(token) {
-    var _a;
     const [algorithm, payload, signature] = token.split('.');
     if (algorithm === undefined ||
         payload === undefined ||
@@ -1175,7 +1174,7 @@ function _parseToken(token) {
         return JSON.parse(decoded);
     }
     catch (e) {
-        _logError('Caught error parsing JWT payload as JSON', (_a = e) === null || _a === void 0 ? void 0 : _a.toString());
+        _logError('Caught error parsing JWT payload as JSON', e === null || e === void 0 ? void 0 : e.toString());
         return null;
     }
 }
@@ -1184,9 +1183,9 @@ function _parseToken(token) {
  */
 function _tokenExpiresIn(token) {
     const parsedToken = _parseToken(token);
-    _assert(parsedToken, "internal-error" /* INTERNAL_ERROR */);
-    _assert(typeof parsedToken.exp !== 'undefined', "internal-error" /* INTERNAL_ERROR */);
-    _assert(typeof parsedToken.iat !== 'undefined', "internal-error" /* INTERNAL_ERROR */);
+    _assert(parsedToken, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
+    _assert(typeof parsedToken.exp !== 'undefined', "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
+    _assert(typeof parsedToken.iat !== 'undefined', "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
     return Number(parsedToken.exp) - Number(parsedToken.iat);
 }
 
@@ -1223,8 +1222,8 @@ async function _logoutIfInvalidated(user, promise, bypassAuthState = false) {
     }
 }
 function isUserInvalidated({ code }) {
-    return (code === `auth/${"user-disabled" /* USER_DISABLED */}` ||
-        code === `auth/${"user-token-expired" /* TOKEN_EXPIRED */}`);
+    return (code === `auth/${"user-disabled" /* AuthErrorCode.USER_DISABLED */}` ||
+        code === `auth/${"user-token-expired" /* AuthErrorCode.TOKEN_EXPIRED */}`);
 }
 
 /**
@@ -1252,7 +1251,7 @@ class ProactiveRefresh {
         // we can't cast properly in both environments.
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         this.timerId = null;
-        this.errorBackoff = 30000 /* RETRY_BACKOFF_MIN */;
+        this.errorBackoff = 30000 /* Duration.RETRY_BACKOFF_MIN */;
     }
     _start() {
         if (this.isRunning) {
@@ -1274,14 +1273,14 @@ class ProactiveRefresh {
         var _a;
         if (wasError) {
             const interval = this.errorBackoff;
-            this.errorBackoff = Math.min(this.errorBackoff * 2, 960000 /* RETRY_BACKOFF_MAX */);
+            this.errorBackoff = Math.min(this.errorBackoff * 2, 960000 /* Duration.RETRY_BACKOFF_MAX */);
             return interval;
         }
         else {
             // Reset the error backoff
-            this.errorBackoff = 30000 /* RETRY_BACKOFF_MIN */;
+            this.errorBackoff = 30000 /* Duration.RETRY_BACKOFF_MIN */;
             const expTime = (_a = this.user.stsTokenManager.expirationTime) !== null && _a !== void 0 ? _a : 0;
-            const interval = expTime - Date.now() - 300000 /* OFFSET */;
+            const interval = expTime - Date.now() - 300000 /* Duration.OFFSET */;
             return Math.max(0, interval);
         }
     }
@@ -1296,14 +1295,13 @@ class ProactiveRefresh {
         }, interval);
     }
     async iteration() {
-        var _a;
         try {
             await this.user.getIdToken(true);
         }
         catch (e) {
             // Only retry on network errors
-            if (((_a = e) === null || _a === void 0 ? void 0 : _a.code) ===
-                `auth/${"network-request-failed" /* NETWORK_REQUEST_FAILED */}`) {
+            if ((e === null || e === void 0 ? void 0 : e.code) ===
+                `auth/${"network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */}`) {
                 this.schedule(/* wasError */ true);
             }
             return;
@@ -1372,7 +1370,7 @@ async function _reloadWithoutSaving(user) {
     const auth = user.auth;
     const idToken = await user.getIdToken();
     const response = await _logoutIfInvalidated(user, getAccountInfo(auth, { idToken }));
-    _assert(response === null || response === void 0 ? void 0 : response.users.length, auth, "internal-error" /* INTERNAL_ERROR */);
+    _assert(response === null || response === void 0 ? void 0 : response.users.length, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
     const coreAccount = response.users[0];
     user._notifyReloadListener(coreAccount);
     const newProviderData = ((_a = coreAccount.providerUserInfo) === null || _a === void 0 ? void 0 : _a.length)
@@ -1458,11 +1456,11 @@ async function requestStsToken(auth, refreshToken) {
             'refresh_token': refreshToken
         }).slice(1);
         const { tokenApiHost, apiKey } = auth.config;
-        const url = _getFinalTarget(auth, tokenApiHost, "/v1/token" /* TOKEN */, `key=${apiKey}`);
+        const url = _getFinalTarget(auth, tokenApiHost, "/v1/token" /* Endpoint.TOKEN */, `key=${apiKey}`);
         const headers = await auth._getAdditionalHeaders();
-        headers["Content-Type" /* CONTENT_TYPE */] = 'application/x-www-form-urlencoded';
+        headers["Content-Type" /* HttpHeader.CONTENT_TYPE */] = 'application/x-www-form-urlencoded';
         return FetchProvider.fetch()(url, {
-            method: "POST" /* POST */,
+            method: "POST" /* HttpMethod.POST */,
             headers,
             body
         });
@@ -1505,19 +1503,19 @@ class StsTokenManager {
     }
     get isExpired() {
         return (!this.expirationTime ||
-            Date.now() > this.expirationTime - 30000 /* TOKEN_REFRESH */);
+            Date.now() > this.expirationTime - 30000 /* Buffer.TOKEN_REFRESH */);
     }
     updateFromServerResponse(response) {
-        _assert(response.idToken, "internal-error" /* INTERNAL_ERROR */);
-        _assert(typeof response.idToken !== 'undefined', "internal-error" /* INTERNAL_ERROR */);
-        _assert(typeof response.refreshToken !== 'undefined', "internal-error" /* INTERNAL_ERROR */);
+        _assert(response.idToken, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
+        _assert(typeof response.idToken !== 'undefined', "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
+        _assert(typeof response.refreshToken !== 'undefined', "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         const expiresIn = 'expiresIn' in response && typeof response.expiresIn !== 'undefined'
             ? Number(response.expiresIn)
             : _tokenExpiresIn(response.idToken);
         this.updateTokensAndExpiration(response.idToken, response.refreshToken, expiresIn);
     }
     async getToken(auth, forceRefresh = false) {
-        _assert(!this.accessToken || this.refreshToken, auth, "user-token-expired" /* TOKEN_EXPIRED */);
+        _assert(!this.accessToken || this.refreshToken, auth, "user-token-expired" /* AuthErrorCode.TOKEN_EXPIRED */);
         if (!forceRefresh && this.accessToken && !this.isExpired) {
             return this.accessToken;
         }
@@ -1543,19 +1541,19 @@ class StsTokenManager {
         const { refreshToken, accessToken, expirationTime } = object;
         const manager = new StsTokenManager();
         if (refreshToken) {
-            _assert(typeof refreshToken === 'string', "internal-error" /* INTERNAL_ERROR */, {
+            _assert(typeof refreshToken === 'string', "internal-error" /* AuthErrorCode.INTERNAL_ERROR */, {
                 appName
             });
             manager.refreshToken = refreshToken;
         }
         if (accessToken) {
-            _assert(typeof accessToken === 'string', "internal-error" /* INTERNAL_ERROR */, {
+            _assert(typeof accessToken === 'string', "internal-error" /* AuthErrorCode.INTERNAL_ERROR */, {
                 appName
             });
             manager.accessToken = accessToken;
         }
         if (expirationTime) {
-            _assert(typeof expirationTime === 'number', "internal-error" /* INTERNAL_ERROR */, {
+            _assert(typeof expirationTime === 'number', "internal-error" /* AuthErrorCode.INTERNAL_ERROR */, {
                 appName
             });
             manager.expirationTime = expirationTime;
@@ -1599,13 +1597,13 @@ class StsTokenManager {
  * limitations under the License.
  */
 function assertStringOrUndefined(assertion, appName) {
-    _assert(typeof assertion === 'string' || typeof assertion === 'undefined', "internal-error" /* INTERNAL_ERROR */, { appName });
+    _assert(typeof assertion === 'string' || typeof assertion === 'undefined', "internal-error" /* AuthErrorCode.INTERNAL_ERROR */, { appName });
 }
 class UserImpl {
     constructor(_a) {
         var { uid, auth, stsTokenManager } = _a, opt = __rest(_a, ["uid", "auth", "stsTokenManager"]);
         // For the user object, provider is always Firebase.
-        this.providerId = "firebase" /* FIREBASE */;
+        this.providerId = "firebase" /* ProviderId.FIREBASE */;
         this.proactiveRefresh = new ProactiveRefresh(this);
         this.reloadUserInfo = null;
         this.reloadListener = null;
@@ -1625,7 +1623,7 @@ class UserImpl {
     }
     async getIdToken(forceRefresh) {
         const accessToken = await _logoutIfInvalidated(this, this.stsTokenManager.getToken(this.auth, forceRefresh));
-        _assert(accessToken, this.auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(accessToken, this.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         if (this.accessToken !== accessToken) {
             this.accessToken = accessToken;
             await this.auth._persistUserIfCurrent(this);
@@ -1643,7 +1641,7 @@ class UserImpl {
         if (this === user) {
             return;
         }
-        _assert(this.uid === user.uid, this.auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(this.uid === user.uid, this.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         this.displayName = user.displayName;
         this.photoURL = user.photoURL;
         this.email = user.email;
@@ -1660,7 +1658,7 @@ class UserImpl {
     }
     _onReload(callback) {
         // There should only ever be one listener, and that is a single instance of MultiFactorUser
-        _assert(!this.reloadListener, this.auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(!this.reloadListener, this.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         this.reloadListener = callback;
         if (this.reloadUserInfo) {
             this._notifyReloadListener(this.reloadUserInfo);
@@ -1727,13 +1725,13 @@ class UserImpl {
         const createdAt = (_g = object.createdAt) !== null && _g !== void 0 ? _g : undefined;
         const lastLoginAt = (_h = object.lastLoginAt) !== null && _h !== void 0 ? _h : undefined;
         const { uid, emailVerified, isAnonymous, providerData, stsTokenManager: plainObjectTokenManager } = object;
-        _assert(uid && plainObjectTokenManager, auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(uid && plainObjectTokenManager, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         const stsTokenManager = StsTokenManager.fromJSON(this.name, plainObjectTokenManager);
-        _assert(typeof uid === 'string', auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(typeof uid === 'string', auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         assertStringOrUndefined(displayName, auth.name);
         assertStringOrUndefined(email, auth.name);
-        _assert(typeof emailVerified === 'boolean', auth, "internal-error" /* INTERNAL_ERROR */);
-        _assert(typeof isAnonymous === 'boolean', auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(typeof emailVerified === 'boolean', auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
+        _assert(typeof isAnonymous === 'boolean', auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         assertStringOrUndefined(phoneNumber, auth.name);
         assertStringOrUndefined(photoURL, auth.name);
         assertStringOrUndefined(tenantId, auth.name);
@@ -1801,7 +1799,7 @@ class UserImpl {
  */
 class InMemoryPersistence {
     constructor() {
-        this.type = "NONE" /* NONE */;
+        this.type = "NONE" /* PersistenceType.NONE */;
         this.storage = {};
     }
     async _isAvailable() {
@@ -1851,7 +1849,7 @@ const inMemoryPersistence = InMemoryPersistence;
  * limitations under the License.
  */
 function _persistenceKeyName(key, apiKey, appName) {
-    return `${"firebase" /* PERSISTENCE */}:${key}:${apiKey}:${appName}`;
+    return `${"firebase" /* Namespace.PERSISTENCE */}:${key}:${apiKey}:${appName}`;
 }
 class PersistenceUserManager {
     constructor(persistence, auth, userKey) {
@@ -1860,7 +1858,7 @@ class PersistenceUserManager {
         this.userKey = userKey;
         const { config, name } = this.auth;
         this.fullUserKey = _persistenceKeyName(this.userKey, config.apiKey, name);
-        this.fullPersistenceKey = _persistenceKeyName("persistence" /* PERSISTENCE_USER */, config.apiKey, name);
+        this.fullPersistenceKey = _persistenceKeyName("persistence" /* KeyName.PERSISTENCE_USER */, config.apiKey, name);
         this.boundEventHandler = auth._onStorageEvent.bind(auth);
         this.persistence._addListener(this.fullUserKey, this.boundEventHandler);
     }
@@ -1891,7 +1889,7 @@ class PersistenceUserManager {
     delete() {
         this.persistence._removeListener(this.fullUserKey, this.boundEventHandler);
     }
-    static async create(auth, persistenceHierarchy, userKey = "authUser" /* AUTH_USER */) {
+    static async create(auth, persistenceHierarchy, userKey = "authUser" /* KeyName.AUTH_USER */) {
         if (!persistenceHierarchy.length) {
             return new PersistenceUserManager(_getInstance(inMemoryPersistence), auth, userKey);
         }
@@ -1976,42 +1974,42 @@ class PersistenceUserManager {
 function _getBrowserName(userAgent) {
     const ua = userAgent.toLowerCase();
     if (ua.includes('opera/') || ua.includes('opr/') || ua.includes('opios/')) {
-        return "Opera" /* OPERA */;
+        return "Opera" /* BrowserName.OPERA */;
     }
     else if (_isIEMobile(ua)) {
         // Windows phone IEMobile browser.
-        return "IEMobile" /* IEMOBILE */;
+        return "IEMobile" /* BrowserName.IEMOBILE */;
     }
     else if (ua.includes('msie') || ua.includes('trident/')) {
-        return "IE" /* IE */;
+        return "IE" /* BrowserName.IE */;
     }
     else if (ua.includes('edge/')) {
-        return "Edge" /* EDGE */;
+        return "Edge" /* BrowserName.EDGE */;
     }
     else if (_isFirefox(ua)) {
-        return "Firefox" /* FIREFOX */;
+        return "Firefox" /* BrowserName.FIREFOX */;
     }
     else if (ua.includes('silk/')) {
-        return "Silk" /* SILK */;
+        return "Silk" /* BrowserName.SILK */;
     }
     else if (_isBlackBerry(ua)) {
         // Blackberry browser.
-        return "Blackberry" /* BLACKBERRY */;
+        return "Blackberry" /* BrowserName.BLACKBERRY */;
     }
     else if (_isWebOS(ua)) {
         // WebOS default browser.
-        return "Webos" /* WEBOS */;
+        return "Webos" /* BrowserName.WEBOS */;
     }
     else if (_isSafari(ua)) {
-        return "Safari" /* SAFARI */;
+        return "Safari" /* BrowserName.SAFARI */;
     }
     else if ((ua.includes('chrome/') || _isChromeIOS(ua)) &&
         !ua.includes('edge/')) {
-        return "Chrome" /* CHROME */;
+        return "Chrome" /* BrowserName.CHROME */;
     }
     else if (_isAndroid(ua)) {
         // Android stock browser.
-        return "Android" /* ANDROID */;
+        return "Android" /* BrowserName.ANDROID */;
     }
     else {
         // Most modern browsers have name/version at end of user agent string.
@@ -2021,7 +2019,7 @@ function _getBrowserName(userAgent) {
             return matches[1];
         }
     }
-    return "Other" /* OTHER */;
+    return "Other" /* BrowserName.OTHER */;
 }
 function _isFirefox(ua = getUA()) {
     return /firefox\//i.test(ua);
@@ -2105,11 +2103,11 @@ function _isIframe() {
 function _getClientVersion(clientPlatform, frameworks = []) {
     let reportedPlatform;
     switch (clientPlatform) {
-        case "Browser" /* BROWSER */:
+        case "Browser" /* ClientPlatform.BROWSER */:
             // In a browser environment, report the browser name.
             reportedPlatform = _getBrowserName(getUA());
             break;
-        case "Worker" /* WORKER */:
+        case "Worker" /* ClientPlatform.WORKER */:
             // Technically a worker runs from a browser but we need to differentiate a
             // worker from a browser.
             // For example: Chrome-Worker/JsCore/4.9.1/FirebaseCore-web.
@@ -2121,7 +2119,7 @@ function _getClientVersion(clientPlatform, frameworks = []) {
     const reportedFrameworks = frameworks.length
         ? frameworks.join(',')
         : 'FirebaseCore-web'; /* default value if no other framework is used */
-    return `${reportedPlatform}/${"JsCore" /* CORE */}/${SDK_VERSION}/${reportedFrameworks}`;
+    return `${reportedPlatform}/${"JsCore" /* ClientImplementation.CORE */}/${SDK_VERSION}/${reportedFrameworks}`;
 }
 
 /**
@@ -2171,7 +2169,6 @@ class AuthMiddlewareQueue {
         };
     }
     async runMiddleware(nextUser) {
-        var _a;
         if (this.auth.currentUser === nextUser) {
             return;
         }
@@ -2199,8 +2196,8 @@ class AuthMiddlewareQueue {
                     /* swallow error */
                 }
             }
-            throw this.auth._errorFactory.create("login-blocked" /* LOGIN_BLOCKED */, {
-                originalMessage: (_a = e) === null || _a === void 0 ? void 0 : _a.message
+            throw this.auth._errorFactory.create("login-blocked" /* AuthErrorCode.LOGIN_BLOCKED */, {
+                originalMessage: e === null || e === void 0 ? void 0 : e.message
             });
         }
     }
@@ -2360,7 +2357,7 @@ class AuthImpl {
                 return this.directlySetCurrentUser(null);
             }
         }
-        _assert(this._popupRedirectResolver, this, "argument-error" /* ARGUMENT_ERROR */);
+        _assert(this._popupRedirectResolver, this, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
         await this.getOrInitRedirectPersistenceManager();
         // If the redirect user's event ID matches the current user's event ID,
         // DO NOT reload the current user, otherwise they'll be cleared from storage.
@@ -2401,13 +2398,12 @@ class AuthImpl {
         return result;
     }
     async reloadAndSetCurrentUserOrClear(user) {
-        var _a;
         try {
             await _reloadWithoutSaving(user);
         }
         catch (e) {
-            if (((_a = e) === null || _a === void 0 ? void 0 : _a.code) !==
-                `auth/${"network-request-failed" /* NETWORK_REQUEST_FAILED */}`) {
+            if ((e === null || e === void 0 ? void 0 : e.code) !==
+                `auth/${"network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */}`) {
                 // Something's wrong with the user's token. Log them out and remove
                 // them from storage
                 return this.directlySetCurrentUser(null);
@@ -2428,7 +2424,7 @@ class AuthImpl {
             ? getModularInstance(userExtern)
             : null;
         if (user) {
-            _assert(user.auth.config.apiKey === this.config.apiKey, this, "invalid-user-token" /* INVALID_AUTH */);
+            _assert(user.auth.config.apiKey === this.config.apiKey, this, "invalid-user-token" /* AuthErrorCode.INVALID_AUTH */);
         }
         return this._updateCurrentUser(user && user._clone(this));
     }
@@ -2437,7 +2433,7 @@ class AuthImpl {
             return;
         }
         if (user) {
-            _assert(this.tenantId === user.tenantId, this, "tenant-id-mismatch" /* TENANT_ID_MISMATCH */);
+            _assert(this.tenantId === user.tenantId, this, "tenant-id-mismatch" /* AuthErrorCode.TENANT_ID_MISMATCH */);
         }
         if (!skipBeforeStateCallbacks) {
             await this.beforeStateQueue.runMiddleware(user);
@@ -2497,8 +2493,8 @@ class AuthImpl {
         if (!this.redirectPersistenceManager) {
             const resolver = (popupRedirectResolver && _getInstance(popupRedirectResolver)) ||
                 this._popupRedirectResolver;
-            _assert(resolver, this, "argument-error" /* ARGUMENT_ERROR */);
-            this.redirectPersistenceManager = await PersistenceUserManager.create(this, [_getInstance(resolver._redirectPersistence)], "redirectUser" /* REDIRECT_USER */);
+            _assert(resolver, this, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+            this.redirectPersistenceManager = await PersistenceUserManager.create(this, [_getInstance(resolver._redirectPersistence)], "redirectUser" /* KeyName.REDIRECT_USER */);
             this.redirectUser =
                 await this.redirectPersistenceManager.getCurrentUser();
         }
@@ -2571,7 +2567,7 @@ class AuthImpl {
         const promise = this._isInitialized
             ? Promise.resolve()
             : this._initializationPromise;
-        _assert(promise, this, "internal-error" /* INTERNAL_ERROR */);
+        _assert(promise, this, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         // The callback needs to be called asynchronously per the spec.
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         promise.then(() => cb(this.currentUser));
@@ -2609,7 +2605,7 @@ class AuthImpl {
         return this.operations;
     }
     get assertedPersistence() {
-        _assert(this.persistenceManager, this, "internal-error" /* INTERNAL_ERROR */);
+        _assert(this.persistenceManager, this, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         return this.persistenceManager;
     }
     _logFramework(framework) {
@@ -2629,10 +2625,10 @@ class AuthImpl {
         var _a;
         // Additional headers on every request
         const headers = {
-            ["X-Client-Version" /* X_CLIENT_VERSION */]: this.clientVersion
+            ["X-Client-Version" /* HttpHeader.X_CLIENT_VERSION */]: this.clientVersion
         };
         if (this.app.options.appId) {
-            headers["X-Firebase-gmpid" /* X_FIREBASE_GMPID */] = this.app.options.appId;
+            headers["X-Firebase-gmpid" /* HttpHeader.X_FIREBASE_GMPID */] = this.app.options.appId;
         }
         // If the heartbeat service exists, add the heartbeat string
         const heartbeatsHeader = await ((_a = this.heartbeatServiceProvider
@@ -2640,7 +2636,7 @@ class AuthImpl {
             optional: true
         })) === null || _a === void 0 ? void 0 : _a.getHeartbeatsHeader());
         if (heartbeatsHeader) {
-            headers["X-Firebase-Client" /* X_FIREBASE_CLIENT */] = heartbeatsHeader;
+            headers["X-Firebase-Client" /* HttpHeader.X_FIREBASE_CLIENT */] = heartbeatsHeader;
         }
         return headers;
     }
@@ -2662,7 +2658,7 @@ class Subscription {
         this.addObserver = createSubscribe(observer => (this.observer = observer));
     }
     get next() {
-        _assert(this.observer, this.auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(this.observer, this.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         return this.observer.next.bind(this.observer);
     }
 }
@@ -2691,8 +2687,8 @@ class Subscription {
  */
 function connectAuthEmulator(auth, url, options) {
     const authInternal = _castAuth(auth);
-    _assert(authInternal._canInitEmulator, authInternal, "emulator-config-failed" /* EMULATOR_CONFIG_FAILED */);
-    _assert(/^https?:\/\//.test(url), authInternal, "invalid-emulator-scheme" /* INVALID_EMULATOR_SCHEME */);
+    _assert(authInternal._canInitEmulator, authInternal, "emulator-config-failed" /* AuthErrorCode.EMULATOR_CONFIG_FAILED */);
+    _assert(/^https?:\/\//.test(url), authInternal, "invalid-emulator-scheme" /* AuthErrorCode.INVALID_EMULATOR_SCHEME */);
     const disableWarnings = !!(options === null || options === void 0 ? void 0 : options.disableWarnings);
     const protocol = extractProtocol(url);
     const { host, port } = extractHostAndPort(url);
@@ -2860,13 +2856,13 @@ class AuthCredential {
  * limitations under the License.
  */
 async function resetPassword(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v1/accounts:resetPassword" /* RESET_PASSWORD */, _addTidIfNecessary(auth, request));
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:resetPassword" /* Endpoint.RESET_PASSWORD */, _addTidIfNecessary(auth, request));
 }
 async function updateEmailPassword(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v1/accounts:update" /* SET_ACCOUNT_INFO */, request);
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:update" /* Endpoint.SET_ACCOUNT_INFO */, request);
 }
 async function applyActionCode$1(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v1/accounts:update" /* SET_ACCOUNT_INFO */, _addTidIfNecessary(auth, request));
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:update" /* Endpoint.SET_ACCOUNT_INFO */, _addTidIfNecessary(auth, request));
 }
 
 /**
@@ -2886,10 +2882,10 @@ async function applyActionCode$1(auth, request) {
  * limitations under the License.
  */
 async function signInWithPassword(auth, request) {
-    return _performSignInRequest(auth, "POST" /* POST */, "/v1/accounts:signInWithPassword" /* SIGN_IN_WITH_PASSWORD */, _addTidIfNecessary(auth, request));
+    return _performSignInRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:signInWithPassword" /* Endpoint.SIGN_IN_WITH_PASSWORD */, _addTidIfNecessary(auth, request));
 }
 async function sendOobCode(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v1/accounts:sendOobCode" /* SEND_OOB_CODE */, _addTidIfNecessary(auth, request));
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:sendOobCode" /* Endpoint.SEND_OOB_CODE */, _addTidIfNecessary(auth, request));
 }
 async function sendEmailVerification$1(auth, request) {
     return sendOobCode(auth, request);
@@ -2921,10 +2917,10 @@ async function verifyAndChangeEmail(auth, request) {
  * limitations under the License.
  */
 async function signInWithEmailLink$1(auth, request) {
-    return _performSignInRequest(auth, "POST" /* POST */, "/v1/accounts:signInWithEmailLink" /* SIGN_IN_WITH_EMAIL_LINK */, _addTidIfNecessary(auth, request));
+    return _performSignInRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:signInWithEmailLink" /* Endpoint.SIGN_IN_WITH_EMAIL_LINK */, _addTidIfNecessary(auth, request));
 }
 async function signInWithEmailLinkForLinking(auth, request) {
-    return _performSignInRequest(auth, "POST" /* POST */, "/v1/accounts:signInWithEmailLink" /* SIGN_IN_WITH_EMAIL_LINK */, _addTidIfNecessary(auth, request));
+    return _performSignInRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:signInWithEmailLink" /* Endpoint.SIGN_IN_WITH_EMAIL_LINK */, _addTidIfNecessary(auth, request));
 }
 
 /**
@@ -2962,18 +2958,18 @@ class EmailAuthCredential extends AuthCredential {
     _password, signInMethod, 
     /** @internal */
     _tenantId = null) {
-        super("password" /* PASSWORD */, signInMethod);
+        super("password" /* ProviderId.PASSWORD */, signInMethod);
         this._email = _email;
         this._password = _password;
         this._tenantId = _tenantId;
     }
     /** @internal */
     static _fromEmailAndPassword(email, password) {
-        return new EmailAuthCredential(email, password, "password" /* EMAIL_PASSWORD */);
+        return new EmailAuthCredential(email, password, "password" /* SignInMethod.EMAIL_PASSWORD */);
     }
     /** @internal */
     static _fromEmailAndCode(email, oobCode, tenantId = null) {
-        return new EmailAuthCredential(email, oobCode, "emailLink" /* EMAIL_LINK */, tenantId);
+        return new EmailAuthCredential(email, oobCode, "emailLink" /* SignInMethod.EMAIL_LINK */, tenantId);
     }
     /** {@inheritdoc AuthCredential.toJSON} */
     toJSON() {
@@ -2995,10 +2991,10 @@ class EmailAuthCredential extends AuthCredential {
     static fromJSON(json) {
         const obj = typeof json === 'string' ? JSON.parse(json) : json;
         if ((obj === null || obj === void 0 ? void 0 : obj.email) && (obj === null || obj === void 0 ? void 0 : obj.password)) {
-            if (obj.signInMethod === "password" /* EMAIL_PASSWORD */) {
+            if (obj.signInMethod === "password" /* SignInMethod.EMAIL_PASSWORD */) {
                 return this._fromEmailAndPassword(obj.email, obj.password);
             }
-            else if (obj.signInMethod === "emailLink" /* EMAIL_LINK */) {
+            else if (obj.signInMethod === "emailLink" /* SignInMethod.EMAIL_LINK */) {
                 return this._fromEmailAndCode(obj.email, obj.password, obj.tenantId);
             }
         }
@@ -3007,39 +3003,39 @@ class EmailAuthCredential extends AuthCredential {
     /** @internal */
     async _getIdTokenResponse(auth) {
         switch (this.signInMethod) {
-            case "password" /* EMAIL_PASSWORD */:
+            case "password" /* SignInMethod.EMAIL_PASSWORD */:
                 return signInWithPassword(auth, {
                     returnSecureToken: true,
                     email: this._email,
                     password: this._password
                 });
-            case "emailLink" /* EMAIL_LINK */:
+            case "emailLink" /* SignInMethod.EMAIL_LINK */:
                 return signInWithEmailLink$1(auth, {
                     email: this._email,
                     oobCode: this._password
                 });
             default:
-                _fail(auth, "internal-error" /* INTERNAL_ERROR */);
+                _fail(auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         }
     }
     /** @internal */
     async _linkToIdToken(auth, idToken) {
         switch (this.signInMethod) {
-            case "password" /* EMAIL_PASSWORD */:
+            case "password" /* SignInMethod.EMAIL_PASSWORD */:
                 return updateEmailPassword(auth, {
                     idToken,
                     returnSecureToken: true,
                     email: this._email,
                     password: this._password
                 });
-            case "emailLink" /* EMAIL_LINK */:
+            case "emailLink" /* SignInMethod.EMAIL_LINK */:
                 return signInWithEmailLinkForLinking(auth, {
                     idToken,
                     email: this._email,
                     oobCode: this._password
                 });
             default:
-                _fail(auth, "internal-error" /* INTERNAL_ERROR */);
+                _fail(auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         }
     }
     /** @internal */
@@ -3065,7 +3061,7 @@ class EmailAuthCredential extends AuthCredential {
  * limitations under the License.
  */
 async function signInWithIdp(auth, request) {
-    return _performSignInRequest(auth, "POST" /* POST */, "/v1/accounts:signInWithIdp" /* SIGN_IN_WITH_IDP */, _addTidIfNecessary(auth, request));
+    return _performSignInRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:signInWithIdp" /* Endpoint.SIGN_IN_WITH_IDP */, _addTidIfNecessary(auth, request));
 }
 
 /**
@@ -3123,7 +3119,7 @@ class OAuthCredential extends AuthCredential {
             cred.secret = params.oauthTokenSecret;
         }
         else {
-            _fail("argument-error" /* ARGUMENT_ERROR */);
+            _fail("argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
         }
         return cred;
     }
@@ -3225,24 +3221,24 @@ class OAuthCredential extends AuthCredential {
  * limitations under the License.
  */
 async function sendPhoneVerificationCode(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v1/accounts:sendVerificationCode" /* SEND_VERIFICATION_CODE */, _addTidIfNecessary(auth, request));
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:sendVerificationCode" /* Endpoint.SEND_VERIFICATION_CODE */, _addTidIfNecessary(auth, request));
 }
 async function signInWithPhoneNumber$1(auth, request) {
-    return _performSignInRequest(auth, "POST" /* POST */, "/v1/accounts:signInWithPhoneNumber" /* SIGN_IN_WITH_PHONE_NUMBER */, _addTidIfNecessary(auth, request));
+    return _performSignInRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:signInWithPhoneNumber" /* Endpoint.SIGN_IN_WITH_PHONE_NUMBER */, _addTidIfNecessary(auth, request));
 }
 async function linkWithPhoneNumber$1(auth, request) {
-    const response = await _performSignInRequest(auth, "POST" /* POST */, "/v1/accounts:signInWithPhoneNumber" /* SIGN_IN_WITH_PHONE_NUMBER */, _addTidIfNecessary(auth, request));
+    const response = await _performSignInRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:signInWithPhoneNumber" /* Endpoint.SIGN_IN_WITH_PHONE_NUMBER */, _addTidIfNecessary(auth, request));
     if (response.temporaryProof) {
-        throw _makeTaggedError(auth, "account-exists-with-different-credential" /* NEED_CONFIRMATION */, response);
+        throw _makeTaggedError(auth, "account-exists-with-different-credential" /* AuthErrorCode.NEED_CONFIRMATION */, response);
     }
     return response;
 }
 const VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_ = {
-    ["USER_NOT_FOUND" /* USER_NOT_FOUND */]: "user-not-found" /* USER_DELETED */
+    ["USER_NOT_FOUND" /* ServerError.USER_NOT_FOUND */]: "user-not-found" /* AuthErrorCode.USER_DELETED */
 };
 async function verifyPhoneNumberForExisting(auth, request) {
     const apiRequest = Object.assign(Object.assign({}, request), { operation: 'REAUTH' });
-    return _performSignInRequest(auth, "POST" /* POST */, "/v1/accounts:signInWithPhoneNumber" /* SIGN_IN_WITH_PHONE_NUMBER */, _addTidIfNecessary(auth, apiRequest), VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_);
+    return _performSignInRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:signInWithPhoneNumber" /* Endpoint.SIGN_IN_WITH_PHONE_NUMBER */, _addTidIfNecessary(auth, apiRequest), VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_);
 }
 
 /**
@@ -3268,7 +3264,7 @@ async function verifyPhoneNumberForExisting(auth, request) {
  */
 class PhoneAuthCredential extends AuthCredential {
     constructor(params) {
-        super("phone" /* PHONE */, "phone" /* PHONE */);
+        super("phone" /* ProviderId.PHONE */, "phone" /* SignInMethod.PHONE */);
         this.params = params;
     }
     /** @internal */
@@ -3366,17 +3362,17 @@ class PhoneAuthCredential extends AuthCredential {
 function parseMode(mode) {
     switch (mode) {
         case 'recoverEmail':
-            return "RECOVER_EMAIL" /* RECOVER_EMAIL */;
+            return "RECOVER_EMAIL" /* ActionCodeOperation.RECOVER_EMAIL */;
         case 'resetPassword':
-            return "PASSWORD_RESET" /* PASSWORD_RESET */;
+            return "PASSWORD_RESET" /* ActionCodeOperation.PASSWORD_RESET */;
         case 'signIn':
-            return "EMAIL_SIGNIN" /* EMAIL_SIGNIN */;
+            return "EMAIL_SIGNIN" /* ActionCodeOperation.EMAIL_SIGNIN */;
         case 'verifyEmail':
-            return "VERIFY_EMAIL" /* VERIFY_EMAIL */;
+            return "VERIFY_EMAIL" /* ActionCodeOperation.VERIFY_EMAIL */;
         case 'verifyAndChangeEmail':
-            return "VERIFY_AND_CHANGE_EMAIL" /* VERIFY_AND_CHANGE_EMAIL */;
+            return "VERIFY_AND_CHANGE_EMAIL" /* ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL */;
         case 'revertSecondFactorAddition':
-            return "REVERT_SECOND_FACTOR_ADDITION" /* REVERT_SECOND_FACTOR_ADDITION */;
+            return "REVERT_SECOND_FACTOR_ADDITION" /* ActionCodeOperation.REVERT_SECOND_FACTOR_ADDITION */;
         default:
             return null;
     }
@@ -3415,17 +3411,17 @@ class ActionCodeURL {
     constructor(actionLink) {
         var _a, _b, _c, _d, _e, _f;
         const searchParams = querystringDecode(extractQuerystring(actionLink));
-        const apiKey = (_a = searchParams["apiKey" /* API_KEY */]) !== null && _a !== void 0 ? _a : null;
-        const code = (_b = searchParams["oobCode" /* CODE */]) !== null && _b !== void 0 ? _b : null;
-        const operation = parseMode((_c = searchParams["mode" /* MODE */]) !== null && _c !== void 0 ? _c : null);
+        const apiKey = (_a = searchParams["apiKey" /* QueryField.API_KEY */]) !== null && _a !== void 0 ? _a : null;
+        const code = (_b = searchParams["oobCode" /* QueryField.CODE */]) !== null && _b !== void 0 ? _b : null;
+        const operation = parseMode((_c = searchParams["mode" /* QueryField.MODE */]) !== null && _c !== void 0 ? _c : null);
         // Validate API key, code and mode.
-        _assert(apiKey && code && operation, "argument-error" /* ARGUMENT_ERROR */);
+        _assert(apiKey && code && operation, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
         this.apiKey = apiKey;
         this.operation = operation;
         this.code = code;
-        this.continueUrl = (_d = searchParams["continueUrl" /* CONTINUE_URL */]) !== null && _d !== void 0 ? _d : null;
-        this.languageCode = (_e = searchParams["languageCode" /* LANGUAGE_CODE */]) !== null && _e !== void 0 ? _e : null;
-        this.tenantId = (_f = searchParams["tenantId" /* TENANT_ID */]) !== null && _f !== void 0 ? _f : null;
+        this.continueUrl = (_d = searchParams["continueUrl" /* QueryField.CONTINUE_URL */]) !== null && _d !== void 0 ? _d : null;
+        this.languageCode = (_e = searchParams["languageCode" /* QueryField.LANGUAGE_CODE */]) !== null && _e !== void 0 ? _e : null;
+        this.tenantId = (_f = searchParams["tenantId" /* QueryField.TENANT_ID */]) !== null && _f !== void 0 ? _f : null;
     }
     /**
      * Parses the email action link string and returns an {@link ActionCodeURL} if the link is valid,
@@ -3529,22 +3525,22 @@ class EmailAuthProvider {
      */
     static credentialWithLink(email, emailLink) {
         const actionCodeUrl = ActionCodeURL.parseLink(emailLink);
-        _assert(actionCodeUrl, "argument-error" /* ARGUMENT_ERROR */);
+        _assert(actionCodeUrl, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
         return EmailAuthCredential._fromEmailAndCode(email, actionCodeUrl.code, actionCodeUrl.tenantId);
     }
 }
 /**
  * Always set to {@link ProviderId}.PASSWORD, even for email link.
  */
-EmailAuthProvider.PROVIDER_ID = "password" /* PASSWORD */;
+EmailAuthProvider.PROVIDER_ID = "password" /* ProviderId.PASSWORD */;
 /**
  * Always set to {@link SignInMethod}.EMAIL_PASSWORD.
  */
-EmailAuthProvider.EMAIL_PASSWORD_SIGN_IN_METHOD = "password" /* EMAIL_PASSWORD */;
+EmailAuthProvider.EMAIL_PASSWORD_SIGN_IN_METHOD = "password" /* SignInMethod.EMAIL_PASSWORD */;
 /**
  * Always set to {@link SignInMethod}.EMAIL_LINK.
  */
-EmailAuthProvider.EMAIL_LINK_SIGN_IN_METHOD = "emailLink" /* EMAIL_LINK */;
+EmailAuthProvider.EMAIL_LINK_SIGN_IN_METHOD = "emailLink" /* SignInMethod.EMAIL_LINK */;
 
 /**
  * @license
@@ -3706,7 +3702,7 @@ class OAuthProvider extends BaseOAuthProvider {
      */
     static credentialFromJSON(json) {
         const obj = typeof json === 'string' ? JSON.parse(json) : json;
-        _assert('providerId' in obj && 'signInMethod' in obj, "argument-error" /* ARGUMENT_ERROR */);
+        _assert('providerId' in obj && 'signInMethod' in obj, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
         return OAuthCredential._fromParams(obj);
     }
     /**
@@ -3735,7 +3731,7 @@ class OAuthProvider extends BaseOAuthProvider {
     }
     /** An internal credential method that accepts more permissive options */
     _credential(params) {
-        _assert(params.idToken || params.accessToken, "argument-error" /* ARGUMENT_ERROR */);
+        _assert(params.idToken || params.accessToken, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
         // For OAuthCredential, sign in method is same as providerId.
         return OAuthCredential._fromParams(Object.assign(Object.assign({}, params), { providerId: this.providerId, signInMethod: this.providerId }));
     }
@@ -3841,7 +3837,7 @@ class OAuthProvider extends BaseOAuthProvider {
  */
 class FacebookAuthProvider extends BaseOAuthProvider {
     constructor() {
-        super("facebook.com" /* FACEBOOK */);
+        super("facebook.com" /* ProviderId.FACEBOOK */);
     }
     /**
      * Creates a credential for Facebook.
@@ -3895,9 +3891,9 @@ class FacebookAuthProvider extends BaseOAuthProvider {
     }
 }
 /** Always set to {@link SignInMethod}.FACEBOOK. */
-FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD = "facebook.com" /* FACEBOOK */;
+FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD = "facebook.com" /* SignInMethod.FACEBOOK */;
 /** Always set to {@link ProviderId}.FACEBOOK. */
-FacebookAuthProvider.PROVIDER_ID = "facebook.com" /* FACEBOOK */;
+FacebookAuthProvider.PROVIDER_ID = "facebook.com" /* ProviderId.FACEBOOK */;
 
 /**
  * @license
@@ -3958,7 +3954,7 @@ FacebookAuthProvider.PROVIDER_ID = "facebook.com" /* FACEBOOK */;
  */
 class GoogleAuthProvider extends BaseOAuthProvider {
     constructor() {
-        super("google.com" /* GOOGLE */);
+        super("google.com" /* ProviderId.GOOGLE */);
         this.addScope('profile');
     }
     /**
@@ -4017,9 +4013,9 @@ class GoogleAuthProvider extends BaseOAuthProvider {
     }
 }
 /** Always set to {@link SignInMethod}.GOOGLE. */
-GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD = "google.com" /* GOOGLE */;
+GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD = "google.com" /* SignInMethod.GOOGLE */;
 /** Always set to {@link ProviderId}.GOOGLE. */
-GoogleAuthProvider.PROVIDER_ID = "google.com" /* GOOGLE */;
+GoogleAuthProvider.PROVIDER_ID = "google.com" /* ProviderId.GOOGLE */;
 
 /**
  * @license
@@ -4081,7 +4077,7 @@ GoogleAuthProvider.PROVIDER_ID = "google.com" /* GOOGLE */;
  */
 class GithubAuthProvider extends BaseOAuthProvider {
     constructor() {
-        super("github.com" /* GITHUB */);
+        super("github.com" /* ProviderId.GITHUB */);
     }
     /**
      * Creates a credential for Github.
@@ -4128,9 +4124,9 @@ class GithubAuthProvider extends BaseOAuthProvider {
     }
 }
 /** Always set to {@link SignInMethod}.GITHUB. */
-GithubAuthProvider.GITHUB_SIGN_IN_METHOD = "github.com" /* GITHUB */;
+GithubAuthProvider.GITHUB_SIGN_IN_METHOD = "github.com" /* SignInMethod.GITHUB */;
 /** Always set to {@link ProviderId}.GITHUB. */
-GithubAuthProvider.PROVIDER_ID = "github.com" /* GITHUB */;
+GithubAuthProvider.PROVIDER_ID = "github.com" /* ProviderId.GITHUB */;
 
 /**
  * @license
@@ -4248,7 +4244,7 @@ class SAMLAuthProvider extends FederatedAuthProvider {
      * @param providerId - SAML provider ID.
      */
     constructor(providerId) {
-        _assert(providerId.startsWith(SAML_PROVIDER_PREFIX), "argument-error" /* ARGUMENT_ERROR */);
+        _assert(providerId.startsWith(SAML_PROVIDER_PREFIX), "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
         super(providerId);
     }
     /**
@@ -4285,7 +4281,7 @@ class SAMLAuthProvider extends FederatedAuthProvider {
      */
     static credentialFromJSON(json) {
         const credential = SAMLAuthCredential.fromJSON(json);
-        _assert(credential, "argument-error" /* ARGUMENT_ERROR */);
+        _assert(credential, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
         return credential;
     }
     static samlCredentialFromTaggedObject({ _tokenResponse: tokenResponse }) {
@@ -4362,7 +4358,7 @@ class SAMLAuthProvider extends FederatedAuthProvider {
  */
 class TwitterAuthProvider extends BaseOAuthProvider {
     constructor() {
-        super("twitter.com" /* TWITTER */);
+        super("twitter.com" /* ProviderId.TWITTER */);
     }
     /**
      * Creates a credential for Twitter.
@@ -4412,9 +4408,9 @@ class TwitterAuthProvider extends BaseOAuthProvider {
     }
 }
 /** Always set to {@link SignInMethod}.TWITTER. */
-TwitterAuthProvider.TWITTER_SIGN_IN_METHOD = "twitter.com" /* TWITTER */;
+TwitterAuthProvider.TWITTER_SIGN_IN_METHOD = "twitter.com" /* SignInMethod.TWITTER */;
 /** Always set to {@link ProviderId}.TWITTER. */
-TwitterAuthProvider.PROVIDER_ID = "twitter.com" /* TWITTER */;
+TwitterAuthProvider.PROVIDER_ID = "twitter.com" /* ProviderId.TWITTER */;
 
 /**
  * @license
@@ -4433,7 +4429,7 @@ TwitterAuthProvider.PROVIDER_ID = "twitter.com" /* TWITTER */;
  * limitations under the License.
  */
 async function signUp(auth, request) {
-    return _performSignInRequest(auth, "POST" /* POST */, "/v1/accounts:signUp" /* SIGN_UP */, _addTidIfNecessary(auth, request));
+    return _performSignInRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:signUp" /* Endpoint.SIGN_UP */, _addTidIfNecessary(auth, request));
 }
 
 /**
@@ -4486,7 +4482,7 @@ function providerIdForResponse(response) {
         return response.providerId;
     }
     if ('phoneNumber' in response) {
-        return "phone" /* PHONE */;
+        return "phone" /* ProviderId.PHONE */;
     }
     return null;
 }
@@ -4527,13 +4523,13 @@ async function signInAnonymously(auth) {
         return new UserCredentialImpl({
             user: authInternal.currentUser,
             providerId: null,
-            operationType: "signIn" /* SIGN_IN */
+            operationType: "signIn" /* OperationType.SIGN_IN */
         });
     }
     const response = await signUp(authInternal, {
         returnSecureToken: true
     });
-    const userCredential = await UserCredentialImpl._fromIdTokenResponse(authInternal, "signIn" /* SIGN_IN */, response, true);
+    const userCredential = await UserCredentialImpl._fromIdTokenResponse(authInternal, "signIn" /* OperationType.SIGN_IN */, response, true);
     await authInternal._updateCurrentUser(userCredential.user);
     return userCredential;
 }
@@ -4574,11 +4570,11 @@ class MultiFactorError extends FirebaseError {
     }
 }
 function _processCredentialSavingMfaContextIfNecessary(auth, operationType, credential, user) {
-    const idTokenProvider = operationType === "reauthenticate" /* REAUTHENTICATE */
+    const idTokenProvider = operationType === "reauthenticate" /* OperationType.REAUTHENTICATE */
         ? credential._getReauthenticationResolver(auth)
         : credential._getIdTokenResponse(auth);
     return idTokenProvider.catch(error => {
-        if (error.code === `auth/${"multi-factor-auth-required" /* MFA_REQUIRED */}`) {
+        if (error.code === `auth/${"multi-factor-auth-required" /* AuthErrorCode.MFA_REQUIRED */}`) {
             throw MultiFactorError._fromErrorAndOperation(auth, error, operationType, user);
         }
         throw error;
@@ -4643,7 +4639,7 @@ async function unlink(user, providerId) {
     });
     const providersLeft = providerDataAsNames(providerUserInfo || []);
     userInternal.providerData = userInternal.providerData.filter(pd => providersLeft.has(pd.providerId));
-    if (!providersLeft.has("phone" /* PHONE */)) {
+    if (!providersLeft.has("phone" /* ProviderId.PHONE */)) {
         userInternal.phoneNumber = null;
     }
     await userInternal.auth._persistUserIfCurrent(userInternal);
@@ -4651,14 +4647,14 @@ async function unlink(user, providerId) {
 }
 async function _link$1(user, credential, bypassAuthState = false) {
     const response = await _logoutIfInvalidated(user, credential._linkToIdToken(user.auth, await user.getIdToken()), bypassAuthState);
-    return UserCredentialImpl._forOperation(user, "link" /* LINK */, response);
+    return UserCredentialImpl._forOperation(user, "link" /* OperationType.LINK */, response);
 }
 async function _assertLinkedStatus(expected, user, provider) {
     await _reloadWithoutSaving(user);
     const providerIds = providerDataAsNames(user.providerData);
     const code = expected === false
-        ? "provider-already-linked" /* PROVIDER_ALREADY_LINKED */
-        : "no-such-provider" /* NO_SUCH_PROVIDER */;
+        ? "provider-already-linked" /* AuthErrorCode.PROVIDER_ALREADY_LINKED */
+        : "no-such-provider" /* AuthErrorCode.NO_SUCH_PROVIDER */;
     _assert(providerIds.has(provider) === expected, user.auth, code);
 }
 
@@ -4679,22 +4675,21 @@ async function _assertLinkedStatus(expected, user, provider) {
  * limitations under the License.
  */
 async function _reauthenticate(user, credential, bypassAuthState = false) {
-    var _a;
     const { auth } = user;
-    const operationType = "reauthenticate" /* REAUTHENTICATE */;
+    const operationType = "reauthenticate" /* OperationType.REAUTHENTICATE */;
     try {
         const response = await _logoutIfInvalidated(user, _processCredentialSavingMfaContextIfNecessary(auth, operationType, credential, user), bypassAuthState);
-        _assert(response.idToken, auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(response.idToken, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         const parsed = _parseToken(response.idToken);
-        _assert(parsed, auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(parsed, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         const { sub: localId } = parsed;
-        _assert(user.uid === localId, auth, "user-mismatch" /* USER_MISMATCH */);
+        _assert(user.uid === localId, auth, "user-mismatch" /* AuthErrorCode.USER_MISMATCH */);
         return UserCredentialImpl._forOperation(user, operationType, response);
     }
     catch (e) {
         // Convert user deleted error into user mismatch
-        if (((_a = e) === null || _a === void 0 ? void 0 : _a.code) === `auth/${"user-not-found" /* USER_DELETED */}`) {
-            _fail(auth, "user-mismatch" /* USER_MISMATCH */);
+        if ((e === null || e === void 0 ? void 0 : e.code) === `auth/${"user-not-found" /* AuthErrorCode.USER_DELETED */}`) {
+            _fail(auth, "user-mismatch" /* AuthErrorCode.USER_MISMATCH */);
         }
         throw e;
     }
@@ -4717,7 +4712,7 @@ async function _reauthenticate(user, credential, bypassAuthState = false) {
  * limitations under the License.
  */
 async function _signInWithCredential(auth, credential, bypassAuthState = false) {
-    const operationType = "signIn" /* SIGN_IN */;
+    const operationType = "signIn" /* OperationType.SIGN_IN */;
     const response = await _processCredentialSavingMfaContextIfNecessary(auth, operationType, credential);
     const userCredential = await UserCredentialImpl._fromIdTokenResponse(auth, operationType, response);
     if (!bypassAuthState) {
@@ -4788,7 +4783,7 @@ async function reauthenticateWithCredential(user, credential) {
  * limitations under the License.
  */
 async function signInWithCustomToken$1(auth, request) {
-    return _performSignInRequest(auth, "POST" /* POST */, "/v1/accounts:signInWithCustomToken" /* SIGN_IN_WITH_CUSTOM_TOKEN */, _addTidIfNecessary(auth, request));
+    return _performSignInRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:signInWithCustomToken" /* Endpoint.SIGN_IN_WITH_CUSTOM_TOKEN */, _addTidIfNecessary(auth, request));
 }
 
 /**
@@ -4829,7 +4824,7 @@ async function signInWithCustomToken(auth, customToken) {
         token: customToken,
         returnSecureToken: true
     });
-    const cred = await UserCredentialImpl._fromIdTokenResponse(authInternal, "signIn" /* SIGN_IN */, response);
+    const cred = await UserCredentialImpl._fromIdTokenResponse(authInternal, "signIn" /* OperationType.SIGN_IN */, response);
     await authInternal._updateCurrentUser(cred.user);
     return cred;
 }
@@ -4861,12 +4856,12 @@ class MultiFactorInfoImpl {
         if ('phoneInfo' in enrollment) {
             return PhoneMultiFactorInfoImpl._fromServerResponse(auth, enrollment);
         }
-        return _fail(auth, "internal-error" /* INTERNAL_ERROR */);
+        return _fail(auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
     }
 }
 class PhoneMultiFactorInfoImpl extends MultiFactorInfoImpl {
     constructor(response) {
-        super("phone" /* PHONE */, response);
+        super("phone" /* FactorId.PHONE */, response);
         this.phoneNumber = response.phoneInfo;
     }
     static _fromServerResponse(_auth, enrollment) {
@@ -4892,18 +4887,18 @@ class PhoneMultiFactorInfoImpl extends MultiFactorInfoImpl {
  */
 function _setActionCodeSettingsOnRequest(auth, request, actionCodeSettings) {
     var _a;
-    _assert(((_a = actionCodeSettings.url) === null || _a === void 0 ? void 0 : _a.length) > 0, auth, "invalid-continue-uri" /* INVALID_CONTINUE_URI */);
+    _assert(((_a = actionCodeSettings.url) === null || _a === void 0 ? void 0 : _a.length) > 0, auth, "invalid-continue-uri" /* AuthErrorCode.INVALID_CONTINUE_URI */);
     _assert(typeof actionCodeSettings.dynamicLinkDomain === 'undefined' ||
-        actionCodeSettings.dynamicLinkDomain.length > 0, auth, "invalid-dynamic-link-domain" /* INVALID_DYNAMIC_LINK_DOMAIN */);
+        actionCodeSettings.dynamicLinkDomain.length > 0, auth, "invalid-dynamic-link-domain" /* AuthErrorCode.INVALID_DYNAMIC_LINK_DOMAIN */);
     request.continueUrl = actionCodeSettings.url;
     request.dynamicLinkDomain = actionCodeSettings.dynamicLinkDomain;
     request.canHandleCodeInApp = actionCodeSettings.handleCodeInApp;
     if (actionCodeSettings.iOS) {
-        _assert(actionCodeSettings.iOS.bundleId.length > 0, auth, "missing-ios-bundle-id" /* MISSING_IOS_BUNDLE_ID */);
+        _assert(actionCodeSettings.iOS.bundleId.length > 0, auth, "missing-ios-bundle-id" /* AuthErrorCode.MISSING_IOS_BUNDLE_ID */);
         request.iOSBundleId = actionCodeSettings.iOS.bundleId;
     }
     if (actionCodeSettings.android) {
-        _assert(actionCodeSettings.android.packageName.length > 0, auth, "missing-android-pkg-name" /* MISSING_ANDROID_PACKAGE_NAME */);
+        _assert(actionCodeSettings.android.packageName.length > 0, auth, "missing-android-pkg-name" /* AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME */);
         request.androidInstallApp = actionCodeSettings.android.installApp;
         request.androidMinimumVersionCode =
             actionCodeSettings.android.minimumVersion;
@@ -4962,7 +4957,7 @@ function _setActionCodeSettingsOnRequest(auth, request, actionCodeSettings) {
 async function sendPasswordResetEmail(auth, email, actionCodeSettings) {
     const authModular = getModularInstance(auth);
     const request = {
-        requestType: "PASSWORD_RESET" /* PASSWORD_RESET */,
+        requestType: "PASSWORD_RESET" /* ActionCodeOperation.PASSWORD_RESET */,
         email
     };
     if (actionCodeSettings) {
@@ -5017,18 +5012,18 @@ async function checkActionCode(auth, oobCode) {
     // Multi-factor info could not be empty if the request type is
     // REVERT_SECOND_FACTOR_ADDITION.
     const operation = response.requestType;
-    _assert(operation, authModular, "internal-error" /* INTERNAL_ERROR */);
+    _assert(operation, authModular, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
     switch (operation) {
-        case "EMAIL_SIGNIN" /* EMAIL_SIGNIN */:
+        case "EMAIL_SIGNIN" /* ActionCodeOperation.EMAIL_SIGNIN */:
             break;
-        case "VERIFY_AND_CHANGE_EMAIL" /* VERIFY_AND_CHANGE_EMAIL */:
-            _assert(response.newEmail, authModular, "internal-error" /* INTERNAL_ERROR */);
+        case "VERIFY_AND_CHANGE_EMAIL" /* ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL */:
+            _assert(response.newEmail, authModular, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
             break;
-        case "REVERT_SECOND_FACTOR_ADDITION" /* REVERT_SECOND_FACTOR_ADDITION */:
-            _assert(response.mfaInfo, authModular, "internal-error" /* INTERNAL_ERROR */);
+        case "REVERT_SECOND_FACTOR_ADDITION" /* ActionCodeOperation.REVERT_SECOND_FACTOR_ADDITION */:
+            _assert(response.mfaInfo, authModular, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         // fall through
         default:
-            _assert(response.email, authModular, "internal-error" /* INTERNAL_ERROR */);
+            _assert(response.email, authModular, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
     }
     // The multi-factor info for revert second factor addition
     let multiFactorInfo = null;
@@ -5037,10 +5032,10 @@ async function checkActionCode(auth, oobCode) {
     }
     return {
         data: {
-            email: (response.requestType === "VERIFY_AND_CHANGE_EMAIL" /* VERIFY_AND_CHANGE_EMAIL */
+            email: (response.requestType === "VERIFY_AND_CHANGE_EMAIL" /* ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL */
                 ? response.newEmail
                 : response.email) || null,
-            previousEmail: (response.requestType === "VERIFY_AND_CHANGE_EMAIL" /* VERIFY_AND_CHANGE_EMAIL */
+            previousEmail: (response.requestType === "VERIFY_AND_CHANGE_EMAIL" /* ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL */
                 ? response.email
                 : response.newEmail) || null,
             multiFactorInfo
@@ -5087,7 +5082,7 @@ async function createUserWithEmailAndPassword(auth, email, password) {
         email,
         password
     });
-    const userCredential = await UserCredentialImpl._fromIdTokenResponse(authInternal, "signIn" /* SIGN_IN */, response);
+    const userCredential = await UserCredentialImpl._fromIdTokenResponse(authInternal, "signIn" /* OperationType.SIGN_IN */, response);
     await authInternal._updateCurrentUser(userCredential.user);
     return userCredential;
 }
@@ -5168,10 +5163,10 @@ function signInWithEmailAndPassword(auth, email, password) {
 async function sendSignInLinkToEmail(auth, email, actionCodeSettings) {
     const authModular = getModularInstance(auth);
     const request = {
-        requestType: "EMAIL_SIGNIN" /* EMAIL_SIGNIN */,
+        requestType: "EMAIL_SIGNIN" /* ActionCodeOperation.EMAIL_SIGNIN */,
         email
     };
-    _assert(actionCodeSettings.handleCodeInApp, authModular, "argument-error" /* ARGUMENT_ERROR */);
+    _assert(actionCodeSettings.handleCodeInApp, authModular, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
     if (actionCodeSettings) {
         _setActionCodeSettingsOnRequest(authModular, request, actionCodeSettings);
     }
@@ -5187,7 +5182,7 @@ async function sendSignInLinkToEmail(auth, email, actionCodeSettings) {
  */
 function isSignInWithEmailLink(auth, emailLink) {
     const actionCodeUrl = ActionCodeURL.parseLink(emailLink);
-    return (actionCodeUrl === null || actionCodeUrl === void 0 ? void 0 : actionCodeUrl.operation) === "EMAIL_SIGNIN" /* EMAIL_SIGNIN */;
+    return (actionCodeUrl === null || actionCodeUrl === void 0 ? void 0 : actionCodeUrl.operation) === "EMAIL_SIGNIN" /* ActionCodeOperation.EMAIL_SIGNIN */;
 }
 /**
  * Asynchronously signs in using an email and sign-in email link.
@@ -5231,7 +5226,7 @@ async function signInWithEmailLink(auth, email, emailLink) {
     const credential = EmailAuthProvider.credentialWithLink(email, emailLink || _getCurrentUrl());
     // Check if the tenant ID in the email link matches the tenant ID on Auth
     // instance.
-    _assert(credential._tenantId === (authModular.tenantId || null), authModular, "tenant-id-mismatch" /* TENANT_ID_MISMATCH */);
+    _assert(credential._tenantId === (authModular.tenantId || null), authModular, "tenant-id-mismatch" /* AuthErrorCode.TENANT_ID_MISMATCH */);
     return signInWithCredential(authModular, credential);
 }
 
@@ -5252,7 +5247,7 @@ async function signInWithEmailLink(auth, email, emailLink) {
  * limitations under the License.
  */
 async function createAuthUri(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v1/accounts:createAuthUri" /* CREATE_AUTH_URI */, _addTidIfNecessary(auth, request));
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:createAuthUri" /* Endpoint.CREATE_AUTH_URI */, _addTidIfNecessary(auth, request));
 }
 
 /**
@@ -5331,7 +5326,7 @@ async function sendEmailVerification(user, actionCodeSettings) {
     const userInternal = getModularInstance(user);
     const idToken = await user.getIdToken();
     const request = {
-        requestType: "VERIFY_EMAIL" /* VERIFY_EMAIL */,
+        requestType: "VERIFY_EMAIL" /* ActionCodeOperation.VERIFY_EMAIL */,
         idToken
     };
     if (actionCodeSettings) {
@@ -5380,7 +5375,7 @@ async function verifyBeforeUpdateEmail(user, newEmail, actionCodeSettings) {
     const userInternal = getModularInstance(user);
     const idToken = await user.getIdToken();
     const request = {
-        requestType: "VERIFY_AND_CHANGE_EMAIL" /* VERIFY_AND_CHANGE_EMAIL */,
+        requestType: "VERIFY_AND_CHANGE_EMAIL" /* ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL */,
         idToken,
         newEmail
     };
@@ -5412,7 +5407,7 @@ async function verifyBeforeUpdateEmail(user, newEmail, actionCodeSettings) {
  * limitations under the License.
  */
 async function updateProfile$1(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v1/accounts:update" /* SET_ACCOUNT_INFO */, request);
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v1/accounts:update" /* Endpoint.SET_ACCOUNT_INFO */, request);
 }
 
 /**
@@ -5455,7 +5450,7 @@ async function updateProfile(user, { displayName, photoURL: photoUrl }) {
     userInternal.displayName = response.displayName || null;
     userInternal.photoURL = response.photoUrl || null;
     // Update the password provider as well
-    const passwordProvider = userInternal.providerData.find(({ providerId }) => providerId === "password" /* PASSWORD */);
+    const passwordProvider = userInternal.providerData.find(({ providerId }) => providerId === "password" /* ProviderId.PASSWORD */);
     if (passwordProvider) {
         passwordProvider.displayName = userInternal.displayName;
         passwordProvider.photoURL = userInternal.photoURL;
@@ -5544,12 +5539,12 @@ function _fromIdTokenResponse(idTokenResponse) {
         ? JSON.parse(idTokenResponse.rawUserInfo)
         : {};
     const isNewUser = idTokenResponse.isNewUser ||
-        idTokenResponse.kind === "identitytoolkit#SignupNewUserResponse" /* SignupNewUser */;
+        idTokenResponse.kind === "identitytoolkit#SignupNewUserResponse" /* IdTokenResponseKind.SignupNewUser */;
     if (!providerId && (idTokenResponse === null || idTokenResponse === void 0 ? void 0 : idTokenResponse.idToken)) {
         const signInProvider = (_b = (_a = _parseToken(idTokenResponse.idToken)) === null || _a === void 0 ? void 0 : _a.firebase) === null || _b === void 0 ? void 0 : _b['sign_in_provider'];
         if (signInProvider) {
-            const filteredProviderId = signInProvider !== "anonymous" /* ANONYMOUS */ &&
-                signInProvider !== "custom" /* CUSTOM */
+            const filteredProviderId = signInProvider !== "anonymous" /* ProviderId.ANONYMOUS */ &&
+                signInProvider !== "custom" /* ProviderId.CUSTOM */
                 ? signInProvider
                 : null;
             // Uses generic class in accordance with the legacy SDK.
@@ -5560,16 +5555,16 @@ function _fromIdTokenResponse(idTokenResponse) {
         return null;
     }
     switch (providerId) {
-        case "facebook.com" /* FACEBOOK */:
+        case "facebook.com" /* ProviderId.FACEBOOK */:
             return new FacebookAdditionalUserInfo(isNewUser, profile);
-        case "github.com" /* GITHUB */:
+        case "github.com" /* ProviderId.GITHUB */:
             return new GithubAdditionalUserInfo(isNewUser, profile);
-        case "google.com" /* GOOGLE */:
+        case "google.com" /* ProviderId.GOOGLE */:
             return new GoogleAdditionalUserInfo(isNewUser, profile);
-        case "twitter.com" /* TWITTER */:
+        case "twitter.com" /* ProviderId.TWITTER */:
             return new TwitterAdditionalUserInfo(isNewUser, profile, idTokenResponse.screenName || null);
-        case "custom" /* CUSTOM */:
-        case "anonymous" /* ANONYMOUS */:
+        case "custom" /* ProviderId.CUSTOM */:
+        case "anonymous" /* ProviderId.ANONYMOUS */:
             return new GenericAdditionalUserInfo(isNewUser, null);
         default:
             return new GenericAdditionalUserInfo(isNewUser, providerId, profile);
@@ -5590,22 +5585,22 @@ class FederatedAdditionalUserInfoWithUsername extends GenericAdditionalUserInfo
 }
 class FacebookAdditionalUserInfo extends GenericAdditionalUserInfo {
     constructor(isNewUser, profile) {
-        super(isNewUser, "facebook.com" /* FACEBOOK */, profile);
+        super(isNewUser, "facebook.com" /* ProviderId.FACEBOOK */, profile);
     }
 }
 class GithubAdditionalUserInfo extends FederatedAdditionalUserInfoWithUsername {
     constructor(isNewUser, profile) {
-        super(isNewUser, "github.com" /* GITHUB */, profile, typeof (profile === null || profile === void 0 ? void 0 : profile.login) === 'string' ? profile === null || profile === void 0 ? void 0 : profile.login : null);
+        super(isNewUser, "github.com" /* ProviderId.GITHUB */, profile, typeof (profile === null || profile === void 0 ? void 0 : profile.login) === 'string' ? profile === null || profile === void 0 ? void 0 : profile.login : null);
     }
 }
 class GoogleAdditionalUserInfo extends GenericAdditionalUserInfo {
     constructor(isNewUser, profile) {
-        super(isNewUser, "google.com" /* GOOGLE */, profile);
+        super(isNewUser, "google.com" /* ProviderId.GOOGLE */, profile);
     }
 }
 class TwitterAdditionalUserInfo extends FederatedAdditionalUserInfoWithUsername {
     constructor(isNewUser, profile, screenName) {
-        super(isNewUser, "twitter.com" /* TWITTER */, profile, screenName);
+        super(isNewUser, "twitter.com" /* ProviderId.TWITTER */, profile, screenName);
     }
 }
 /**
@@ -5783,13 +5778,13 @@ class MultiFactorSessionImpl {
         this.auth = auth;
     }
     static _fromIdtoken(idToken, auth) {
-        return new MultiFactorSessionImpl("enroll" /* ENROLL */, idToken, auth);
+        return new MultiFactorSessionImpl("enroll" /* MultiFactorSessionType.ENROLL */, idToken, auth);
     }
     static _fromMfaPendingCredential(mfaPendingCredential) {
-        return new MultiFactorSessionImpl("signin" /* SIGN_IN */, mfaPendingCredential);
+        return new MultiFactorSessionImpl("signin" /* MultiFactorSessionType.SIGN_IN */, mfaPendingCredential);
     }
     toJSON() {
-        const key = this.type === "enroll" /* ENROLL */
+        const key = this.type === "enroll" /* MultiFactorSessionType.ENROLL */
             ? 'idToken'
             : 'pendingCredential';
         return {
@@ -5839,7 +5834,7 @@ class MultiFactorResolverImpl {
         const auth = _castAuth(authExtern);
         const serverResponse = error.customData._serverResponse;
         const hints = (serverResponse.mfaInfo || []).map(enrollment => MultiFactorInfoImpl._fromServerResponse(auth, enrollment));
-        _assert(serverResponse.mfaPendingCredential, auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(serverResponse.mfaPendingCredential, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         const session = MultiFactorSessionImpl._fromMfaPendingCredential(serverResponse.mfaPendingCredential);
         return new MultiFactorResolverImpl(session, hints, async (assertion) => {
             const mfaResponse = await assertion._process(auth, session);
@@ -5850,15 +5845,15 @@ class MultiFactorResolverImpl {
             const idTokenResponse = Object.assign(Object.assign({}, serverResponse), { idToken: mfaResponse.idToken, refreshToken: mfaResponse.refreshToken });
             // TODO: we should collapse this switch statement into UserCredentialImpl._forOperation and have it support the SIGN_IN case
             switch (error.operationType) {
-                case "signIn" /* SIGN_IN */:
+                case "signIn" /* OperationType.SIGN_IN */:
                     const userCredential = await UserCredentialImpl._fromIdTokenResponse(auth, error.operationType, idTokenResponse);
                     await auth._updateCurrentUser(userCredential.user);
                     return userCredential;
-                case "reauthenticate" /* REAUTHENTICATE */:
-                    _assert(error.user, auth, "internal-error" /* INTERNAL_ERROR */);
+                case "reauthenticate" /* OperationType.REAUTHENTICATE */:
+                    _assert(error.user, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
                     return UserCredentialImpl._forOperation(error.user, error.operationType, idTokenResponse);
                 default:
-                    _fail(auth, "internal-error" /* INTERNAL_ERROR */);
+                    _fail(auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
             }
         });
     }
@@ -5881,8 +5876,8 @@ function getMultiFactorResolver(auth, error) {
     var _a;
     const authModular = getModularInstance(auth);
     const errorInternal = error;
-    _assert(error.customData.operationType, authModular, "argument-error" /* ARGUMENT_ERROR */);
-    _assert((_a = errorInternal.customData._serverResponse) === null || _a === void 0 ? void 0 : _a.mfaPendingCredential, authModular, "argument-error" /* ARGUMENT_ERROR */);
+    _assert(error.customData.operationType, authModular, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+    _assert((_a = errorInternal.customData._serverResponse) === null || _a === void 0 ? void 0 : _a.mfaPendingCredential, authModular, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
     return MultiFactorResolverImpl._fromError(authModular, errorInternal);
 }
 
@@ -5903,13 +5898,13 @@ function getMultiFactorResolver(auth, error) {
  * limitations under the License.
  */
 function startEnrollPhoneMfa(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v2/accounts/mfaEnrollment:start" /* START_MFA_ENROLLMENT */, _addTidIfNecessary(auth, request));
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v2/accounts/mfaEnrollment:start" /* Endpoint.START_MFA_ENROLLMENT */, _addTidIfNecessary(auth, request));
 }
 function finalizeEnrollPhoneMfa(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v2/accounts/mfaEnrollment:finalize" /* FINALIZE_MFA_ENROLLMENT */, _addTidIfNecessary(auth, request));
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v2/accounts/mfaEnrollment:finalize" /* Endpoint.FINALIZE_MFA_ENROLLMENT */, _addTidIfNecessary(auth, request));
 }
 function withdrawMfa(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v2/accounts/mfaEnrollment:withdraw" /* WITHDRAW_MFA */, _addTidIfNecessary(auth, request));
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v2/accounts/mfaEnrollment:withdraw" /* Endpoint.WITHDRAW_MFA */, _addTidIfNecessary(auth, request));
 }
 
 class MultiFactorUserImpl {
@@ -5941,7 +5936,6 @@ class MultiFactorUserImpl {
         return this.user.reload();
     }
     async unenroll(infoOrUid) {
-        var _a;
         const mfaEnrollmentId = typeof infoOrUid === 'string' ? infoOrUid : infoOrUid.uid;
         const idToken = await this.user.getIdToken();
         const idTokenResponse = await _logoutIfInvalidated(this.user, withdrawMfa(this.user.auth, {
@@ -5959,7 +5953,7 @@ class MultiFactorUserImpl {
             await this.user.reload();
         }
         catch (e) {
-            if (((_a = e) === null || _a === void 0 ? void 0 : _a.code) !== `auth/${"user-token-expired" /* TOKEN_EXPIRED */}`) {
+            if ((e === null || e === void 0 ? void 0 : e.code) !== `auth/${"user-token-expired" /* AuthErrorCode.TOKEN_EXPIRED */}`) {
                 throw e;
             }
         }
@@ -6066,7 +6060,7 @@ const _POLLING_INTERVAL_MS$1 = 1000;
 const IE10_LOCAL_STORAGE_SYNC_DELAY = 10;
 class BrowserLocalPersistence extends BrowserPersistenceClass {
     constructor() {
-        super(() => window.localStorage, "LOCAL" /* LOCAL */);
+        super(() => window.localStorage, "LOCAL" /* PersistenceType.LOCAL */);
         this.boundEventHandler = (event, poll) => this.onStorageEvent(event, poll);
         this.listeners = {};
         this.localCache = {};
@@ -6267,7 +6261,7 @@ const browserLocalPersistence = BrowserLocalPersistence;
  */
 class BrowserSessionPersistence extends BrowserPersistenceClass {
     constructor() {
-        super(() => window.sessionStorage, "SESSION" /* SESSION */);
+        super(() => window.sessionStorage, "SESSION" /* PersistenceType.SESSION */);
     }
     _addListener(_key, _listener) {
         // Listeners are not supported for session storage since it cannot be shared across windows
@@ -6391,14 +6385,14 @@ class Receiver {
             return;
         }
         messageEvent.ports[0].postMessage({
-            status: "ack" /* ACK */,
+            status: "ack" /* _Status.ACK */,
             eventId,
             eventType
         });
         const promises = Array.from(handlers).map(async (handler) => handler(messageEvent.origin, data));
         const response = await _allSettled(promises);
         messageEvent.ports[0].postMessage({
-            status: "done" /* DONE */,
+            status: "done" /* _Status.DONE */,
             eventId,
             eventType,
             response
@@ -6515,10 +6509,10 @@ class Sender {
      *
      * @returns An array of settled promises from all the handlers that were listening on the receiver.
      */
-    async _send(eventType, data, timeout = 50 /* ACK */) {
+    async _send(eventType, data, timeout = 50 /* _TimeoutDuration.ACK */) {
         const messageChannel = typeof MessageChannel !== 'undefined' ? new MessageChannel() : null;
         if (!messageChannel) {
-            throw new Error("connection_unavailable" /* CONNECTION_UNAVAILABLE */);
+            throw new Error("connection_unavailable" /* _MessageError.CONNECTION_UNAVAILABLE */);
         }
         // Node timers and browser timers return fundamentally different types.
         // We don't actually care what the value is but TS won't accept unknown and
@@ -6530,7 +6524,7 @@ class Sender {
             const eventId = _generateEventId('', 20);
             messageChannel.port1.start();
             const ackTimer = setTimeout(() => {
-                reject(new Error("unsupported_event" /* UNSUPPORTED_EVENT */));
+                reject(new Error("unsupported_event" /* _MessageError.UNSUPPORTED_EVENT */));
             }, timeout);
             handler = {
                 messageChannel,
@@ -6540,14 +6534,14 @@ class Sender {
                         return;
                     }
                     switch (messageEvent.data.status) {
-                        case "ack" /* ACK */:
+                        case "ack" /* _Status.ACK */:
                             // The receiver should ACK first.
                             clearTimeout(ackTimer);
                             completionTimer = setTimeout(() => {
-                                reject(new Error("timeout" /* TIMEOUT */));
-                            }, 3000 /* COMPLETION */);
+                                reject(new Error("timeout" /* _MessageError.TIMEOUT */));
+                            }, 3000 /* _TimeoutDuration.COMPLETION */);
                             break;
-                        case "done" /* DONE */:
+                        case "done" /* _Status.DONE */:
                             // Once the receiver's handlers are finished we will get the results.
                             clearTimeout(completionTimer);
                             resolve(messageEvent.data.response);
@@ -6555,7 +6549,7 @@ class Sender {
                         default:
                             clearTimeout(ackTimer);
                             clearTimeout(completionTimer);
-                            reject(new Error("invalid_response" /* INVALID_RESPONSE */));
+                            reject(new Error("invalid_response" /* _MessageError.INVALID_RESPONSE */));
                             break;
                     }
                 }
@@ -6745,7 +6739,7 @@ const _POLLING_INTERVAL_MS = 800;
 const _TRANSACTION_RETRY_COUNT = 3;
 class IndexedDBLocalPersistence {
     constructor() {
-        this.type = "LOCAL" /* LOCAL */;
+        this.type = "LOCAL" /* PersistenceType.LOCAL */;
         this._shouldAllowMigration = true;
         this.listeners = {};
         this.localCache = {};
@@ -6800,15 +6794,15 @@ class IndexedDBLocalPersistence {
     async initializeReceiver() {
         this.receiver = Receiver._getInstance(_getWorkerGlobalScope());
         // Refresh from persistence if we receive a KeyChanged message.
-        this.receiver._subscribe("keyChanged" /* KEY_CHANGED */, async (_origin, data) => {
+        this.receiver._subscribe("keyChanged" /* _EventType.KEY_CHANGED */, async (_origin, data) => {
             const keys = await this._poll();
             return {
                 keyProcessed: keys.includes(data.key)
             };
         });
         // Let the sender know that we are listening so they give us more timeout.
-        this.receiver._subscribe("ping" /* PING */, async (_origin, _data) => {
-            return ["keyChanged" /* KEY_CHANGED */];
+        this.receiver._subscribe("ping" /* _EventType.PING */, async (_origin, _data) => {
+            return ["keyChanged" /* _EventType.KEY_CHANGED */];
         });
     }
     /**
@@ -6827,12 +6821,12 @@ class IndexedDBLocalPersistence {
         }
         this.sender = new Sender(this.activeServiceWorker);
         // Ping the service worker to check what events they can handle.
-        const results = await this.sender._send("ping" /* PING */, {}, 800 /* LONG_ACK */);
+        const results = await this.sender._send("ping" /* _EventType.PING */, {}, 800 /* _TimeoutDuration.LONG_ACK */);
         if (!results) {
             return;
         }
         if (((_a = results[0]) === null || _a === void 0 ? void 0 : _a.fulfilled) &&
-            ((_b = results[0]) === null || _b === void 0 ? void 0 : _b.value.includes("keyChanged" /* KEY_CHANGED */))) {
+            ((_b = results[0]) === null || _b === void 0 ? void 0 : _b.value.includes("keyChanged" /* _EventType.KEY_CHANGED */))) {
             this.serviceWorkerReceiverAvailable = true;
         }
     }
@@ -6852,11 +6846,11 @@ class IndexedDBLocalPersistence {
             return;
         }
         try {
-            await this.sender._send("keyChanged" /* KEY_CHANGED */, { key }, 
+            await this.sender._send("keyChanged" /* _EventType.KEY_CHANGED */, { key }, 
             // Use long timeout if receiver has previously responded to a ping from us.
             this.serviceWorkerReceiverAvailable
-                ? 800 /* LONG_ACK */
-                : 50 /* ACK */);
+                ? 800 /* _TimeoutDuration.LONG_ACK */
+                : 50 /* _TimeoutDuration.ACK */);
         }
         catch (_a) {
             // This is a best effort approach. Ignore errors.
@@ -7002,10 +6996,10 @@ const indexedDBLocalPersistence = IndexedDBLocalPersistence;
  * limitations under the License.
  */
 function startSignInPhoneMfa(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v2/accounts/mfaSignIn:start" /* START_MFA_SIGN_IN */, _addTidIfNecessary(auth, request));
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v2/accounts/mfaSignIn:start" /* Endpoint.START_MFA_SIGN_IN */, _addTidIfNecessary(auth, request));
 }
 function finalizeSignInPhoneMfa(auth, request) {
-    return _performApiRequest(auth, "POST" /* POST */, "/v2/accounts/mfaSignIn:finalize" /* FINALIZE_MFA_SIGN_IN */, _addTidIfNecessary(auth, request));
+    return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v2/accounts/mfaSignIn:finalize" /* Endpoint.FINALIZE_MFA_SIGN_IN */, _addTidIfNecessary(auth, request));
 }
 
 /**
@@ -7025,7 +7019,7 @@ function finalizeSignInPhoneMfa(auth, request) {
  * limitations under the License.
  */
 async function getRecaptchaParams(auth) {
-    return ((await _performApiRequest(auth, "GET" /* GET */, "/v1/recaptchaParams" /* GET_RECAPTCHA_PARAM */)).recaptchaSiteKey || '');
+    return ((await _performApiRequest(auth, "GET" /* HttpMethod.GET */, "/v1/recaptchaParams" /* Endpoint.GET_RECAPTCHA_PARAM */)).recaptchaSiteKey || '');
 }
 
 /**
@@ -7055,7 +7049,7 @@ function _loadJS(url) {
         el.setAttribute('src', url);
         el.onload = resolve;
         el.onerror = e => {
-            const error = _createError("internal-error" /* INTERNAL_ERROR */);
+            const error = _createError("internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
             error.customData = e;
             reject(error);
         };
@@ -7129,7 +7123,7 @@ class MockWidget {
         const container = typeof containerOrId === 'string'
             ? document.getElementById(containerOrId)
             : containerOrId;
-        _assert(container, "argument-error" /* ARGUMENT_ERROR */, { appName });
+        _assert(container, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */, { appName });
         this.container = container;
         this.isVisible = this.params.size !== 'invisible';
         if (this.isVisible) {
@@ -7233,20 +7227,20 @@ class ReCaptchaLoaderImpl {
         this.librarySeparatelyLoaded = !!((_a = _window().grecaptcha) === null || _a === void 0 ? void 0 : _a.render);
     }
     load(auth, hl = '') {
-        _assert(isHostLanguageValid(hl), auth, "argument-error" /* ARGUMENT_ERROR */);
+        _assert(isHostLanguageValid(hl), auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
         if (this.shouldResolveImmediately(hl)) {
             return Promise.resolve(_window().grecaptcha);
         }
         return new Promise((resolve, reject) => {
             const networkTimeout = _window().setTimeout(() => {
-                reject(_createError(auth, "network-request-failed" /* NETWORK_REQUEST_FAILED */));
+                reject(_createError(auth, "network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */));
             }, NETWORK_TIMEOUT_DELAY.get());
             _window()[_JSLOAD_CALLBACK] = () => {
                 _window().clearTimeout(networkTimeout);
                 delete _window()[_JSLOAD_CALLBACK];
                 const recaptcha = _window().grecaptcha;
                 if (!recaptcha) {
-                    reject(_createError(auth, "internal-error" /* INTERNAL_ERROR */));
+                    reject(_createError(auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */));
                     return;
                 }
                 // Wrap the greptcha render function so that we know if the developer has
@@ -7267,7 +7261,7 @@ class ReCaptchaLoaderImpl {
             })}`;
             _loadJS(url).catch(() => {
                 clearTimeout(networkTimeout);
-                reject(_createError(auth, "internal-error" /* INTERNAL_ERROR */));
+                reject(_createError(auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */));
             });
         });
     }
@@ -7362,11 +7356,11 @@ class RecaptchaVerifier {
         this.recaptcha = null;
         this.auth = _castAuth(authExtern);
         this.isInvisible = this.parameters.size === 'invisible';
-        _assert(typeof document !== 'undefined', this.auth, "operation-not-supported-in-this-environment" /* OPERATION_NOT_SUPPORTED */);
+        _assert(typeof document !== 'undefined', this.auth, "operation-not-supported-in-this-environment" /* AuthErrorCode.OPERATION_NOT_SUPPORTED */);
         const container = typeof containerOrId === 'string'
             ? document.getElementById(containerOrId)
             : containerOrId;
-        _assert(container, this.auth, "argument-error" /* ARGUMENT_ERROR */);
+        _assert(container, this.auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
         this.container = container;
         this.parameters.callback = this.makeTokenCallback(this.parameters.callback);
         this._recaptchaLoader = this.auth.settings.appVerificationDisabledForTesting
@@ -7447,9 +7441,9 @@ class RecaptchaVerifier {
         }
     }
     validateStartingState() {
-        _assert(!this.parameters.sitekey, this.auth, "argument-error" /* ARGUMENT_ERROR */);
-        _assert(this.isInvisible || !this.container.hasChildNodes(), this.auth, "argument-error" /* ARGUMENT_ERROR */);
-        _assert(typeof document !== 'undefined', this.auth, "operation-not-supported-in-this-environment" /* OPERATION_NOT_SUPPORTED */);
+        _assert(!this.parameters.sitekey, this.auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+        _assert(this.isInvisible || !this.container.hasChildNodes(), this.auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+        _assert(typeof document !== 'undefined', this.auth, "operation-not-supported-in-this-environment" /* AuthErrorCode.OPERATION_NOT_SUPPORTED */);
     }
     makeTokenCallback(existing) {
         return token => {
@@ -7466,7 +7460,7 @@ class RecaptchaVerifier {
         };
     }
     assertNotDestroyed() {
-        _assert(!this.destroyed, this.auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(!this.destroyed, this.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
     }
     async makeRenderPromise() {
         await this.init();
@@ -7482,15 +7476,15 @@ class RecaptchaVerifier {
         return this.widgetId;
     }
     async init() {
-        _assert(_isHttpOrHttps() && !_isWorker(), this.auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(_isHttpOrHttps() && !_isWorker(), this.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         await domReady();
         this.recaptcha = await this._recaptchaLoader.load(this.auth, this.auth.languageCode || undefined);
         const siteKey = await getRecaptchaParams(this.auth);
-        _assert(siteKey, this.auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(siteKey, this.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         this.parameters.sitekey = siteKey;
     }
     getAssertedRecaptcha() {
-        _assert(this.recaptcha, this.auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(this.recaptcha, this.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         return this.recaptcha;
     }
 }
@@ -7586,7 +7580,7 @@ async function signInWithPhoneNumber(auth, phoneNumber, appVerifier) {
  */
 async function linkWithPhoneNumber(user, phoneNumber, appVerifier) {
     const userInternal = getModularInstance(user);
-    await _assertLinkedStatus(false, userInternal, "phone" /* PHONE */);
+    await _assertLinkedStatus(false, userInternal, "phone" /* ProviderId.PHONE */);
     const verificationId = await _verifyPhoneNumber(userInternal.auth, phoneNumber, getModularInstance(appVerifier));
     return new ConfirmationResultImpl(verificationId, cred => linkWithCredential(userInternal, cred));
 }
@@ -7614,8 +7608,8 @@ async function _verifyPhoneNumber(auth, options, verifier) {
     var _a;
     const recaptchaToken = await verifier.verify();
     try {
-        _assert(typeof recaptchaToken === 'string', auth, "argument-error" /* ARGUMENT_ERROR */);
-        _assert(verifier.type === RECAPTCHA_VERIFIER_TYPE, auth, "argument-error" /* ARGUMENT_ERROR */);
+        _assert(typeof recaptchaToken === 'string', auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+        _assert(verifier.type === RECAPTCHA_VERIFIER_TYPE, auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
         let phoneInfoOptions;
         if (typeof options === 'string') {
             phoneInfoOptions = {
@@ -7628,7 +7622,7 @@ async function _verifyPhoneNumber(auth, options, verifier) {
         if ('session' in phoneInfoOptions) {
             const session = phoneInfoOptions.session;
             if ('phoneNumber' in phoneInfoOptions) {
-                _assert(session.type === "enroll" /* ENROLL */, auth, "internal-error" /* INTERNAL_ERROR */);
+                _assert(session.type === "enroll" /* MultiFactorSessionType.ENROLL */, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
                 const response = await startEnrollPhoneMfa(auth, {
                     idToken: session.credential,
                     phoneEnrollmentInfo: {
@@ -7639,10 +7633,10 @@ async function _verifyPhoneNumber(auth, options, verifier) {
                 return response.phoneSessionInfo.sessionInfo;
             }
             else {
-                _assert(session.type === "signin" /* SIGN_IN */, auth, "internal-error" /* INTERNAL_ERROR */);
+                _assert(session.type === "signin" /* MultiFactorSessionType.SIGN_IN */, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
                 const mfaEnrollmentId = ((_a = phoneInfoOptions.multiFactorHint) === null || _a === void 0 ? void 0 : _a.uid) ||
                     phoneInfoOptions.multiFactorUid;
-                _assert(mfaEnrollmentId, auth, "missing-multi-factor-info" /* MISSING_MFA_INFO */);
+                _assert(mfaEnrollmentId, auth, "missing-multi-factor-info" /* AuthErrorCode.MISSING_MFA_INFO */);
                 const response = await startSignInPhoneMfa(auth, {
                     mfaPendingCredential: session.credential,
                     mfaEnrollmentId,
@@ -7849,9 +7843,9 @@ class PhoneAuthProvider {
     }
 }
 /** Always set to {@link ProviderId}.PHONE. */
-PhoneAuthProvider.PROVIDER_ID = "phone" /* PHONE */;
+PhoneAuthProvider.PROVIDER_ID = "phone" /* ProviderId.PHONE */;
 /** Always set to {@link SignInMethod}.PHONE. */
-PhoneAuthProvider.PHONE_SIGN_IN_METHOD = "phone" /* PHONE */;
+PhoneAuthProvider.PHONE_SIGN_IN_METHOD = "phone" /* SignInMethod.PHONE */;
 
 /**
  * @license
@@ -7878,7 +7872,7 @@ function _withDefaultResolver(auth, resolverOverride) {
     if (resolverOverride) {
         return _getInstance(resolverOverride);
     }
-    _assert(auth._popupRedirectResolver, auth, "argument-error" /* ARGUMENT_ERROR */);
+    _assert(auth._popupRedirectResolver, auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
     return auth._popupRedirectResolver;
 }
 
@@ -7900,7 +7894,7 @@ function _withDefaultResolver(auth, resolverOverride) {
  */
 class IdpCredential extends AuthCredential {
     constructor(params) {
-        super("custom" /* CUSTOM */, "custom" /* CUSTOM */);
+        super("custom" /* ProviderId.CUSTOM */, "custom" /* ProviderId.CUSTOM */);
         this.params = params;
     }
     _getIdTokenResponse(auth) {
@@ -7933,12 +7927,12 @@ function _signIn(params) {
 }
 function _reauth(params) {
     const { auth, user } = params;
-    _assert(user, auth, "internal-error" /* INTERNAL_ERROR */);
+    _assert(user, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
     return _reauthenticate(user, new IdpCredential(params), params.bypassAuthState);
 }
 async function _link(params) {
     const { auth, user } = params;
-    _assert(user, auth, "internal-error" /* INTERNAL_ERROR */);
+    _assert(user, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
     return _link$1(user, new IdpCredential(params), params.bypassAuthState);
 }
 
@@ -8012,17 +8006,17 @@ class AbstractPopupRedirectOperation {
     }
     getIdpTask(type) {
         switch (type) {
-            case "signInViaPopup" /* SIGN_IN_VIA_POPUP */:
-            case "signInViaRedirect" /* SIGN_IN_VIA_REDIRECT */:
+            case "signInViaPopup" /* AuthEventType.SIGN_IN_VIA_POPUP */:
+            case "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */:
                 return _signIn;
-            case "linkViaPopup" /* LINK_VIA_POPUP */:
-            case "linkViaRedirect" /* LINK_VIA_REDIRECT */:
+            case "linkViaPopup" /* AuthEventType.LINK_VIA_POPUP */:
+            case "linkViaRedirect" /* AuthEventType.LINK_VIA_REDIRECT */:
                 return _link;
-            case "reauthViaPopup" /* REAUTH_VIA_POPUP */:
-            case "reauthViaRedirect" /* REAUTH_VIA_REDIRECT */:
+            case "reauthViaPopup" /* AuthEventType.REAUTH_VIA_POPUP */:
+            case "reauthViaRedirect" /* AuthEventType.REAUTH_VIA_REDIRECT */:
                 return _reauth;
             default:
-                _fail(this.auth, "internal-error" /* INTERNAL_ERROR */);
+                _fail(this.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         }
     }
     resolve(cred) {
@@ -8094,7 +8088,7 @@ async function signInWithPopup(auth, provider, resolver) {
     const authInternal = _castAuth(auth);
     _assertInstanceOf(auth, provider, FederatedAuthProvider);
     const resolverInternal = _withDefaultResolver(authInternal, resolver);
-    const action = new PopupOperation(authInternal, "signInViaPopup" /* SIGN_IN_VIA_POPUP */, provider, resolverInternal);
+    const action = new PopupOperation(authInternal, "signInViaPopup" /* AuthEventType.SIGN_IN_VIA_POPUP */, provider, resolverInternal);
     return action.executeNotNull();
 }
 /**
@@ -8126,7 +8120,7 @@ async function reauthenticateWithPopup(user, provider, resolver) {
     const userInternal = getModularInstance(user);
     _assertInstanceOf(userInternal.auth, provider, FederatedAuthProvider);
     const resolverInternal = _withDefaultResolver(userInternal.auth, resolver);
-    const action = new PopupOperation(userInternal.auth, "reauthViaPopup" /* REAUTH_VIA_POPUP */, provider, resolverInternal, userInternal);
+    const action = new PopupOperation(userInternal.auth, "reauthViaPopup" /* AuthEventType.REAUTH_VIA_POPUP */, provider, resolverInternal, userInternal);
     return action.executeNotNull();
 }
 /**
@@ -8157,7 +8151,7 @@ async function linkWithPopup(user, provider, resolver) {
     const userInternal = getModularInstance(user);
     _assertInstanceOf(userInternal.auth, provider, FederatedAuthProvider);
     const resolverInternal = _withDefaultResolver(userInternal.auth, resolver);
-    const action = new PopupOperation(userInternal.auth, "linkViaPopup" /* LINK_VIA_POPUP */, provider, resolverInternal, userInternal);
+    const action = new PopupOperation(userInternal.auth, "linkViaPopup" /* AuthEventType.LINK_VIA_POPUP */, provider, resolverInternal, userInternal);
     return action.executeNotNull();
 }
 /**
@@ -8178,7 +8172,7 @@ class PopupOperation extends AbstractPopupRedirectOperation {
     }
     async executeNotNull() {
         const result = await this.execute();
-        _assert(result, this.auth, "internal-error" /* INTERNAL_ERROR */);
+        _assert(result, this.auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         return result;
     }
     async onExecution() {
@@ -8199,7 +8193,7 @@ class PopupOperation extends AbstractPopupRedirectOperation {
         });
         this.resolver._isIframeWebStorageSupported(this.auth, isSupported => {
             if (!isSupported) {
-                this.reject(_createError(this.auth, "web-storage-unsupported" /* WEB_STORAGE_UNSUPPORTED */));
+                this.reject(_createError(this.auth, "web-storage-unsupported" /* AuthErrorCode.WEB_STORAGE_UNSUPPORTED */));
             }
         });
         // Handle user closure. Notice this does *not* use await
@@ -8210,7 +8204,7 @@ class PopupOperation extends AbstractPopupRedirectOperation {
         return ((_a = this.authWindow) === null || _a === void 0 ? void 0 : _a.associatedEvent) || null;
     }
     cancel() {
-        this.reject(_createError(this.auth, "cancelled-popup-request" /* EXPIRED_POPUP_REQUEST */));
+        this.reject(_createError(this.auth, "cancelled-popup-request" /* AuthErrorCode.EXPIRED_POPUP_REQUEST */));
     }
     cleanUp() {
         if (this.authWindow) {
@@ -8232,8 +8226,8 @@ class PopupOperation extends AbstractPopupRedirectOperation {
                 // call could still be in flight.
                 this.pollId = window.setTimeout(() => {
                     this.pollId = null;
-                    this.reject(_createError(this.auth, "popup-closed-by-user" /* POPUP_CLOSED_BY_USER */));
-                }, 2000 /* AUTH_EVENT */);
+                    this.reject(_createError(this.auth, "popup-closed-by-user" /* AuthErrorCode.POPUP_CLOSED_BY_USER */));
+                }, 2000 /* _Timeout.AUTH_EVENT */);
                 return;
             }
             this.pollId = window.setTimeout(poll, _POLL_WINDOW_CLOSE_TIMEOUT.get());
@@ -8268,10 +8262,10 @@ const redirectOutcomeMap = new Map();
 class RedirectAction extends AbstractPopupRedirectOperation {
     constructor(auth, resolver, bypassAuthState = false) {
         super(auth, [
-            "signInViaRedirect" /* SIGN_IN_VIA_REDIRECT */,
-            "linkViaRedirect" /* LINK_VIA_REDIRECT */,
-            "reauthViaRedirect" /* REAUTH_VIA_REDIRECT */,
-            "unknown" /* UNKNOWN */
+            "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */,
+            "linkViaRedirect" /* AuthEventType.LINK_VIA_REDIRECT */,
+            "reauthViaRedirect" /* AuthEventType.REAUTH_VIA_REDIRECT */,
+            "unknown" /* AuthEventType.UNKNOWN */
         ], resolver, undefined, bypassAuthState);
         this.eventId = null;
     }
@@ -8300,10 +8294,10 @@ class RedirectAction extends AbstractPopupRedirectOperation {
         return readyOutcome();
     }
     async onAuthEvent(event) {
-        if (event.type === "signInViaRedirect" /* SIGN_IN_VIA_REDIRECT */) {
+        if (event.type === "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */) {
             return super.onAuthEvent(event);
         }
-        else if (event.type === "unknown" /* UNKNOWN */) {
+        else if (event.type === "unknown" /* AuthEventType.UNKNOWN */) {
             // This is a sentinel value indicating there's no pending redirect
             this.resolve(null);
             return;
@@ -8411,7 +8405,7 @@ async function _signInWithRedirect(auth, provider, resolver) {
     _assertInstanceOf(auth, provider, FederatedAuthProvider);
     const resolverInternal = _withDefaultResolver(authInternal, resolver);
     await _setPendingRedirectStatus(resolverInternal, authInternal);
-    return resolverInternal._openRedirect(authInternal, provider, "signInViaRedirect" /* SIGN_IN_VIA_REDIRECT */);
+    return resolverInternal._openRedirect(authInternal, provider, "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */);
 }
 /**
  * Reauthenticates the current user with the specified {@link OAuthProvider} using a full-page redirect flow.
@@ -8451,7 +8445,7 @@ async function _reauthenticateWithRedirect(user, provider, resolver) {
     const resolverInternal = _withDefaultResolver(userInternal.auth, resolver);
     await _setPendingRedirectStatus(resolverInternal, userInternal.auth);
     const eventId = await prepareUserForRedirect(userInternal);
-    return resolverInternal._openRedirect(userInternal.auth, provider, "reauthViaRedirect" /* REAUTH_VIA_REDIRECT */, eventId);
+    return resolverInternal._openRedirect(userInternal.auth, provider, "reauthViaRedirect" /* AuthEventType.REAUTH_VIA_REDIRECT */, eventId);
 }
 /**
  * Links the {@link OAuthProvider} to the user account using a full-page redirect flow.
@@ -8489,7 +8483,7 @@ async function _linkWithRedirect(user, provider, resolver) {
     await _assertLinkedStatus(false, userInternal, provider.providerId);
     await _setPendingRedirectStatus(resolverInternal, userInternal.auth);
     const eventId = await prepareUserForRedirect(userInternal);
-    return resolverInternal._openRedirect(userInternal.auth, provider, "linkViaRedirect" /* LINK_VIA_REDIRECT */, eventId);
+    return resolverInternal._openRedirect(userInternal.auth, provider, "linkViaRedirect" /* AuthEventType.LINK_VIA_REDIRECT */, eventId);
 }
 /**
  * Returns a {@link UserCredential} from the redirect-based sign-in flow.
@@ -8623,7 +8617,7 @@ class AuthEventManager {
         var _a;
         if (event.error && !isNullRedirectEvent(event)) {
             const code = ((_a = event.error.code) === null || _a === void 0 ? void 0 : _a.split('auth/')[1]) ||
-                "internal-error" /* INTERNAL_ERROR */;
+                "internal-error" /* AuthErrorCode.INTERNAL_ERROR */;
             consumer.onError(_createError(this.auth, code));
         }
         else {
@@ -8651,16 +8645,16 @@ function eventUid(e) {
     return [e.type, e.eventId, e.sessionId, e.tenantId].filter(v => v).join('-');
 }
 function isNullRedirectEvent({ type, error }) {
-    return (type === "unknown" /* UNKNOWN */ &&
-        (error === null || error === void 0 ? void 0 : error.code) === `auth/${"no-auth-event" /* NO_AUTH_EVENT */}`);
+    return (type === "unknown" /* AuthEventType.UNKNOWN */ &&
+        (error === null || error === void 0 ? void 0 : error.code) === `auth/${"no-auth-event" /* AuthErrorCode.NO_AUTH_EVENT */}`);
 }
 function isRedirectEvent(event) {
     switch (event.type) {
-        case "signInViaRedirect" /* SIGN_IN_VIA_REDIRECT */:
-        case "linkViaRedirect" /* LINK_VIA_REDIRECT */:
-        case "reauthViaRedirect" /* REAUTH_VIA_REDIRECT */:
+        case "signInViaRedirect" /* AuthEventType.SIGN_IN_VIA_REDIRECT */:
+        case "linkViaRedirect" /* AuthEventType.LINK_VIA_REDIRECT */:
+        case "reauthViaRedirect" /* AuthEventType.REAUTH_VIA_REDIRECT */:
             return true;
-        case "unknown" /* UNKNOWN */:
+        case "unknown" /* AuthEventType.UNKNOWN */:
             return isNullRedirectEvent(event);
         default:
             return false;
@@ -8684,7 +8678,7 @@ function isRedirectEvent(event) {
  * limitations under the License.
  */
 async function _getProjectConfig(auth, request = {}) {
-    return _performApiRequest(auth, "GET" /* GET */, "/v1/projects" /* GET_PROJECT_CONFIG */, request);
+    return _performApiRequest(auth, "GET" /* HttpMethod.GET */, "/v1/projects" /* Endpoint.GET_PROJECT_CONFIG */, request);
 }
 
 /**
@@ -8722,7 +8716,7 @@ async function _validateOrigin(auth) {
         }
     }
     // In the old SDK, this error also provides helpful messages.
-    _fail(auth, "unauthorized-domain" /* INVALID_ORIGIN */);
+    _fail(auth, "unauthorized-domain" /* AuthErrorCode.INVALID_ORIGIN */);
 }
 function matchDomain(expected) {
     const currentUrl = _getCurrentUrl();
@@ -8819,7 +8813,7 @@ function loadGapi(auth) {
                     // failed attempt.
                     // Timeout when gapi.iframes.Iframe not loaded.
                     resetUnloadedGapiModules();
-                    reject(_createError(auth, "network-request-failed" /* NETWORK_REQUEST_FAILED */));
+                    reject(_createError(auth, "network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */));
                 },
                 timeout: NETWORK_TIMEOUT.get()
             });
@@ -8847,7 +8841,7 @@ function loadGapi(auth) {
                 }
                 else {
                     // Gapi loader failed, throw error.
-                    reject(_createError(auth, "network-request-failed" /* NETWORK_REQUEST_FAILED */));
+                    reject(_createError(auth, "network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */));
                 }
             };
             // Load GApi loader.
@@ -8898,13 +8892,13 @@ const IFRAME_ATTRIBUTES = {
 // Map from apiHost to endpoint ID for passing into iframe. In current SDK, apiHost can be set to
 // anything (not from a list of endpoints with IDs as in legacy), so this is the closest we can get.
 const EID_FROM_APIHOST = new Map([
-    ["identitytoolkit.googleapis.com" /* API_HOST */, 'p'],
+    ["identitytoolkit.googleapis.com" /* DefaultConfig.API_HOST */, 'p'],
     ['staging-identitytoolkit.sandbox.googleapis.com', 's'],
     ['test-identitytoolkit.sandbox.googleapis.com', 't'] // test
 ]);
 function getIframeUrl(auth) {
     const config = auth.config;
-    _assert(config.authDomain, auth, "auth-domain-config-required" /* MISSING_AUTH_DOMAIN */);
+    _assert(config.authDomain, auth, "auth-domain-config-required" /* AuthErrorCode.MISSING_AUTH_DOMAIN */);
     const url = config.emulator
         ? _emulatorUrl(config, EMULATED_IFRAME_PATH)
         : `https://${auth.config.authDomain}/${IFRAME_PATH}`;
@@ -8926,7 +8920,7 @@ function getIframeUrl(auth) {
 async function _openIframe(auth) {
     const context = await _loadGapi(auth);
     const gapi = _window().gapi;
-    _assert(gapi, auth, "internal-error" /* INTERNAL_ERROR */);
+    _assert(gapi, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
     return context.open({
         where: document.body,
         url: getIframeUrl(auth),
@@ -8938,7 +8932,7 @@ async function _openIframe(auth) {
             // Prevent iframe from closing on mouse out.
             setHideOnLeave: false
         });
-        const networkError = _createError(auth, "network-request-failed" /* NETWORK_REQUEST_FAILED */);
+        const networkError = _createError(auth, "network-request-failed" /* AuthErrorCode.NETWORK_REQUEST_FAILED */);
         // Confirm iframe is correctly loaded.
         // To fallback on failure, set a timeout.
         const networkErrorTimer = _window().setTimeout(() => {
@@ -9024,7 +9018,7 @@ function _open(auth, url, name, width = DEFAULT_WIDTH, height = DEFAULT_HEIGHT)
     // about:blank getting sanitized causing browsers like IE/Edge to display
     // brief error message before redirecting to handler.
     const newWin = window.open(url || '', target, optionsString);
-    _assert(newWin, auth, "popup-blocked" /* POPUP_BLOCKED */);
+    _assert(newWin, auth, "popup-blocked" /* AuthErrorCode.POPUP_BLOCKED */);
     // Flaky on IE edge, encapsulate with a try and catch.
     try {
         newWin.focus();
@@ -9070,8 +9064,8 @@ const WIDGET_PATH = '__/auth/handler';
  */
 const EMULATOR_WIDGET_PATH = 'emulator/auth/handler';
 function _getRedirectUrl(auth, provider, authType, redirectUrl, eventId, additionalParams) {
-    _assert(auth.config.authDomain, auth, "auth-domain-config-required" /* MISSING_AUTH_DOMAIN */);
-    _assert(auth.config.apiKey, auth, "invalid-api-key" /* INVALID_API_KEY */);
+    _assert(auth.config.authDomain, auth, "auth-domain-config-required" /* AuthErrorCode.MISSING_AUTH_DOMAIN */);
+    _assert(auth.config.apiKey, auth, "invalid-api-key" /* AuthErrorCode.INVALID_API_KEY */);
     const params = {
         apiKey: auth.config.apiKey,
         appName: auth.name,
@@ -9185,10 +9179,10 @@ class BrowserPopupRedirectResolver {
         const iframe = await _openIframe(auth);
         const manager = new AuthEventManager(auth);
         iframe.register('authEvent', (iframeEvent) => {
-            _assert(iframeEvent === null || iframeEvent === void 0 ? void 0 : iframeEvent.authEvent, auth, "invalid-auth-event" /* INVALID_AUTH_EVENT */);
+            _assert(iframeEvent === null || iframeEvent === void 0 ? void 0 : iframeEvent.authEvent, auth, "invalid-auth-event" /* AuthErrorCode.INVALID_AUTH_EVENT */);
             // TODO: Consider splitting redirect and popup events earlier on
             const handled = manager.onEvent(iframeEvent.authEvent);
-            return { status: handled ? "ACK" /* ACK */ : "ERROR" /* ERROR */ };
+            return { status: handled ? "ACK" /* GapiOutcome.ACK */ : "ERROR" /* GapiOutcome.ERROR */ };
         }, gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER);
         this.eventManagers[auth._key()] = { manager };
         this.iframes[auth._key()] = iframe;
@@ -9202,7 +9196,7 @@ class BrowserPopupRedirectResolver {
             if (isSupported !== undefined) {
                 cb(!!isSupported);
             }
-            _fail(auth, "internal-error" /* INTERNAL_ERROR */);
+            _fail(auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
         }, gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER);
     }
     _originValidation(auth) {
@@ -9231,9 +9225,9 @@ class MultiFactorAssertionImpl {
     }
     _process(auth, session, displayName) {
         switch (session.type) {
-            case "enroll" /* ENROLL */:
+            case "enroll" /* MultiFactorSessionType.ENROLL */:
                 return this._finalizeEnroll(auth, session.credential, displayName);
-            case "signin" /* SIGN_IN */:
+            case "signin" /* MultiFactorSessionType.SIGN_IN */:
                 return this._finalizeSignIn(auth, session.credential);
             default:
                 return debugFail('unexpected MultiFactorSessionType');
@@ -9248,7 +9242,7 @@ class MultiFactorAssertionImpl {
  */
 class PhoneMultiFactorAssertionImpl extends MultiFactorAssertionImpl {
     constructor(credential) {
-        super("phone" /* PHONE */);
+        super("phone" /* FactorId.PHONE */);
         this.credential = credential;
     }
     /** @internal */
@@ -9295,7 +9289,7 @@ class PhoneMultiFactorGenerator {
 PhoneMultiFactorGenerator.FACTOR_ID = 'phone';
 
 var name = "@firebase/auth";
-var version = "0.20.11";
+var version = "0.21.0";
 
 /**
  * @license
@@ -9338,8 +9332,7 @@ class AuthInterop {
             return;
         }
         const unsubscribe = this.auth.onIdTokenChanged(user => {
-            var _a;
-            listener(((_a = user) === null || _a === void 0 ? void 0 : _a.stsTokenManager.accessToken) || null);
+            listener((user === null || user === void 0 ? void 0 : user.stsTokenManager.accessToken) || null);
         });
         this.internalListeners.set(listener, unsubscribe);
         this.updateProactiveRefresh();
@@ -9355,7 +9348,7 @@ class AuthInterop {
         this.updateProactiveRefresh();
     }
     assertAuthConfigured() {
-        _assert(this.auth._initializationPromise, "dependent-sdk-initialized-before-auth" /* DEPENDENT_SDK_INIT_BEFORE_AUTH */);
+        _assert(this.auth._initializationPromise, "dependent-sdk-initialized-before-auth" /* AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH */);
     }
     updateProactiveRefresh() {
         if (this.internalListeners.size > 0) {
@@ -9385,13 +9378,13 @@ class AuthInterop {
  */
 function getVersionForPlatform(clientPlatform) {
     switch (clientPlatform) {
-        case "Node" /* NODE */:
+        case "Node" /* ClientPlatform.NODE */:
             return 'node';
-        case "ReactNative" /* REACT_NATIVE */:
+        case "ReactNative" /* ClientPlatform.REACT_NATIVE */:
             return 'rn';
-        case "Worker" /* WORKER */:
+        case "Worker" /* ClientPlatform.WORKER */:
             return 'webworker';
-        case "Cordova" /* CORDOVA */:
+        case "Cordova" /* ClientPlatform.CORDOVA */:
             return 'cordova';
         default:
             return undefined;
@@ -9399,47 +9392,47 @@ function getVersionForPlatform(clientPlatform) {
 }
 /** @internal */
 function registerAuth(clientPlatform) {
-    _registerComponent(new Component("auth" /* AUTH */, (container, { options: deps }) => {
+    _registerComponent(new Component("auth" /* _ComponentName.AUTH */, (container, { options: deps }) => {
         const app = container.getProvider('app').getImmediate();
         const heartbeatServiceProvider = container.getProvider('heartbeat');
         const { apiKey, authDomain } = app.options;
         return ((app, heartbeatServiceProvider) => {
-            _assert(apiKey && !apiKey.includes(':'), "invalid-api-key" /* INVALID_API_KEY */, { appName: app.name });
+            _assert(apiKey && !apiKey.includes(':'), "invalid-api-key" /* AuthErrorCode.INVALID_API_KEY */, { appName: app.name });
             // Auth domain is optional if IdP sign in isn't being used
-            _assert(!(authDomain === null || authDomain === void 0 ? void 0 : authDomain.includes(':')), "argument-error" /* ARGUMENT_ERROR */, {
+            _assert(!(authDomain === null || authDomain === void 0 ? void 0 : authDomain.includes(':')), "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */, {
                 appName: app.name
             });
             const config = {
                 apiKey,
                 authDomain,
                 clientPlatform,
-                apiHost: "identitytoolkit.googleapis.com" /* API_HOST */,
-                tokenApiHost: "securetoken.googleapis.com" /* TOKEN_API_HOST */,
-                apiScheme: "https" /* API_SCHEME */,
+                apiHost: "identitytoolkit.googleapis.com" /* DefaultConfig.API_HOST */,
+                tokenApiHost: "securetoken.googleapis.com" /* DefaultConfig.TOKEN_API_HOST */,
+                apiScheme: "https" /* DefaultConfig.API_SCHEME */,
                 sdkClientVersion: _getClientVersion(clientPlatform)
             };
             const authInstance = new AuthImpl(app, heartbeatServiceProvider, config);
             _initializeAuthInstance(authInstance, deps);
             return authInstance;
         })(app, heartbeatServiceProvider);
-    }, "PUBLIC" /* PUBLIC */)
+    }, "PUBLIC" /* ComponentType.PUBLIC */)
         /**
          * Auth can only be initialized by explicitly calling getAuth() or initializeAuth()
          * For why we do this, See go/firebase-next-auth-init
          */
-        .setInstantiationMode("EXPLICIT" /* EXPLICIT */)
+        .setInstantiationMode("EXPLICIT" /* InstantiationMode.EXPLICIT */)
         /**
          * Because all firebase products that depend on auth depend on auth-internal directly,
          * we need to initialize auth-internal after auth is initialized to make it available to other firebase products.
          */
         .setInstanceCreatedCallback((container, _instanceIdentifier, _instance) => {
-        const authInternalProvider = container.getProvider("auth-internal" /* AUTH_INTERNAL */);
+        const authInternalProvider = container.getProvider("auth-internal" /* _ComponentName.AUTH_INTERNAL */);
         authInternalProvider.initialize();
     }));
-    _registerComponent(new Component("auth-internal" /* AUTH_INTERNAL */, container => {
-        const auth = _castAuth(container.getProvider("auth" /* AUTH */).getImmediate());
+    _registerComponent(new Component("auth-internal" /* _ComponentName.AUTH_INTERNAL */, container => {
+        const auth = _castAuth(container.getProvider("auth" /* _ComponentName.AUTH */).getImmediate());
         return (auth => new AuthInterop(auth))(auth);
-    }, "PRIVATE" /* PRIVATE */).setInstantiationMode("EXPLICIT" /* EXPLICIT */));
+    }, "PRIVATE" /* ComponentType.PRIVATE */).setInstantiationMode("EXPLICIT" /* InstantiationMode.EXPLICIT */));
     registerVersion(name, version, getVersionForPlatform(clientPlatform));
     // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
     registerVersion(name, version, 'esm2017');
@@ -9519,7 +9512,7 @@ function getAuth(app = getApp()) {
     }
     return auth;
 }
-registerAuth("Browser" /* BROWSER */);
+registerAuth("Browser" /* ClientPlatform.BROWSER */);
 
 export { signInWithCustomToken as $, ActionCodeOperation as A, debugErrorMap as B, prodErrorMap as C, AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as D, initializeAuth as E, FactorId as F, connectAuthEmulator as G, AuthCredential as H, EmailAuthCredential as I, OAuthCredential as J, PhoneAuthCredential as K, inMemoryPersistence as L, EmailAuthProvider as M, FacebookAuthProvider as N, OperationType as O, PhoneAuthProvider as P, GoogleAuthProvider as Q, RecaptchaVerifier as R, SignInMethod as S, GithubAuthProvider as T, OAuthProvider as U, SAMLAuthProvider as V, TwitterAuthProvider as W, signInAnonymously as X, signInWithCredential as Y, linkWithCredential as Z, reauthenticateWithCredential as _, browserSessionPersistence as a, sendPasswordResetEmail as a0, confirmPasswordReset as a1, applyActionCode as a2, checkActionCode as a3, verifyPasswordResetCode as a4, createUserWithEmailAndPassword as a5, signInWithEmailAndPassword as a6, sendSignInLinkToEmail as a7, isSignInWithEmailLink as a8, signInWithEmailLink as a9, _persistenceKeyName as aA, _getRedirectResult as aB, _overrideRedirectResult as aC, _clearRedirectOutcomes as aD, _castAuth as aE, UserImpl as aF, AuthImpl as aG, _getClientVersion as aH, _generateEventId as aI, AuthPopup as aJ, FetchProvider as aK, SAMLAuthCredential as aL, fetchSignInMethodsForEmail as aa, sendEmailVerification as ab, verifyBeforeUpdateEmail as ac, ActionCodeURL as ad, parseActionCodeURL as ae, updateProfile as af, updateEmail as ag, updatePassword as ah, getIdToken as ai, getIdTokenResult as aj, unlink as ak, getAdditionalUserInfo as al, reload as am, getMultiFactorResolver as an, multiFactor as ao, debugAssert as ap, _isIOS as aq, _isAndroid as ar, _fail as as, _getRedirectUrl as at, _getProjectConfig as au, _isIOS7Or8 as av, _createError as aw, _assert as ax, AuthEventManager as ay, _getInstance as az, browserLocalPersistence as b, signInWithPopup as c, linkWithPopup as d, reauthenticateWithPopup as e, signInWithRedirect as f, linkWithRedirect as g, reauthenticateWithRedirect as h, indexedDBLocalPersistence as i, getRedirectResult as j, browserPopupRedirectResolver as k, linkWithPhoneNumber as l, PhoneMultiFactorGenerator as m, getAuth as n, ProviderId as o, setPersistence as p, onIdTokenChanged as q, reauthenticateWithPhoneNumber as r, signInWithPhoneNumber as s, beforeAuthStateChanged as t, updatePhoneNumber as u, onAuthStateChanged as v, useDeviceLanguage as w, updateCurrentUser as x, signOut as y, deleteUser as z };
-//# sourceMappingURL=index-0bb4da3b.js.map
+//# sourceMappingURL=index-c6def6da.js.map