tra-analysis/website/functions/node_modules/firebase-admin/lib/utils/error.js

/*! firebase-admin v6.0.0 */
"use strict";
/*!
 * Copyright 2017 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
var __extends = (this && this.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
var deep_copy_1 = require("../utils/deep-copy");
/**
 * Firebase error code structure. This extends Error.
 *
 * @param {ErrorInfo} errorInfo The error information (code and message).
 * @constructor
 */
var FirebaseError = /** @class */ (function (_super) {
    __extends(FirebaseError, _super);
    function FirebaseError(errorInfo) {
        var _this = _super.call(this, errorInfo.message) || this;
        _this.errorInfo = errorInfo;
        /* tslint:disable:max-line-length */
        // Set the prototype explicitly. See the following link for more details:
        // https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
        /* tslint:enable:max-line-length */
        _this.__proto__ = FirebaseError.prototype;
        return _this;
    }
    Object.defineProperty(FirebaseError.prototype, "code", {
        /** @return {string} The error code. */
        get: function () {
            return this.errorInfo.code;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(FirebaseError.prototype, "message", {
        /** @return {string} The error message. */
        get: function () {
            return this.errorInfo.message;
        },
        enumerable: true,
        configurable: true
    });
    /** @return {object} The object representation of the error. */
    FirebaseError.prototype.toJSON = function () {
        return {
            code: this.code,
            message: this.message,
        };
    };
    return FirebaseError;
}(Error));
exports.FirebaseError = FirebaseError;
/**
 * A FirebaseError with a prefix in front of the error code.
 *
 * @param {string} codePrefix The prefix to apply to the error code.
 * @param {string} code The error code.
 * @param {string} message The error message.
 * @constructor
 */
var PrefixedFirebaseError = /** @class */ (function (_super) {
    __extends(PrefixedFirebaseError, _super);
    function PrefixedFirebaseError(codePrefix, code, message) {
        var _this = _super.call(this, {
            code: codePrefix + "/" + code,
            message: message,
        }) || this;
        _this.codePrefix = codePrefix;
        /* tslint:disable:max-line-length */
        // Set the prototype explicitly. See the following link for more details:
        // https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
        /* tslint:enable:max-line-length */
        _this.__proto__ = PrefixedFirebaseError.prototype;
        return _this;
    }
    /**
     * Allows the error type to be checked without needing to know implementation details
     * of the code prefixing.
     *
     * @param {string} code The non-prefixed error code to test against.
     * @return {boolean} True if the code matches, false otherwise.
     */
    PrefixedFirebaseError.prototype.hasCode = function (code) {
        return this.codePrefix + "/" + code === this.code;
    };
    return PrefixedFirebaseError;
}(FirebaseError));
/**
 * Firebase App error code structure. This extends PrefixedFirebaseError.
 *
 * @param {string} code The error code.
 * @param {string} message The error message.
 * @constructor
 */
var FirebaseAppError = /** @class */ (function (_super) {
    __extends(FirebaseAppError, _super);
    function FirebaseAppError(code, message) {
        var _this = _super.call(this, 'app', code, message) || this;
        /* tslint:disable:max-line-length */
        // Set the prototype explicitly. See the following link for more details:
        // https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
        /* tslint:enable:max-line-length */
        _this.__proto__ = FirebaseAppError.prototype;
        return _this;
    }
    return FirebaseAppError;
}(PrefixedFirebaseError));
exports.FirebaseAppError = FirebaseAppError;
/**
 * Firebase Auth error code structure. This extends PrefixedFirebaseError.
 *
 * @param {ErrorInfo} info The error code info.
 * @param {string} [message] The error message. This will override the default
 *     message if provided.
 * @constructor
 */
var FirebaseAuthError = /** @class */ (function (_super) {
    __extends(FirebaseAuthError, _super);
    function FirebaseAuthError(info, message) {
        var _this = 
        // Override default message if custom message provided.
        _super.call(this, 'auth', info.code, message || info.message) || this;
        /* tslint:disable:max-line-length */
        // Set the prototype explicitly. See the following link for more details:
        // https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
        /* tslint:enable:max-line-length */
        _this.__proto__ = FirebaseAuthError.prototype;
        return _this;
    }
    /**
     * Creates the developer-facing error corresponding to the backend error code.
     *
     * @param {string} serverErrorCode The server error code.
     * @param {string} [message] The error message. The default message is used
     *     if not provided.
     * @param {object} [rawServerResponse] The error's raw server response.
     * @return {FirebaseAuthError} The corresponding developer-facing error.
     */
    FirebaseAuthError.fromServerError = function (serverErrorCode, message, rawServerResponse) {
        // If not found, default to internal error.
        var clientCodeKey = AUTH_SERVER_TO_CLIENT_CODE[serverErrorCode] || 'INTERNAL_ERROR';
        var error = deep_copy_1.deepCopy(AuthClientErrorCode[clientCodeKey]);
        error.message = message || error.message;
        if (clientCodeKey === 'INTERNAL_ERROR' && typeof rawServerResponse !== 'undefined') {
            try {
                error.message += " Raw server response: \"" + JSON.stringify(rawServerResponse) + "\"";
            }
            catch (e) {
                // Ignore JSON parsing error.
            }
        }
        return new FirebaseAuthError(error);
    };
    return FirebaseAuthError;
}(PrefixedFirebaseError));
exports.FirebaseAuthError = FirebaseAuthError;
/**
 * Firebase Database error code structure. This extends FirebaseError.
 *
 * @param {ErrorInfo} info The error code info.
 * @param {string} [message] The error message. This will override the default
 *     message if provided.
 * @constructor
 */
var FirebaseDatabaseError = /** @class */ (function (_super) {
    __extends(FirebaseDatabaseError, _super);
    function FirebaseDatabaseError(info, message) {
        // Override default message if custom message provided.
        return _super.call(this, { code: 'database/' + info.code, message: message || info.message }) || this;
    }
    return FirebaseDatabaseError;
}(FirebaseError));
exports.FirebaseDatabaseError = FirebaseDatabaseError;
/**
 * Firebase Firestore error code structure. This extends FirebaseError.
 *
 * @param {ErrorInfo} info The error code info.
 * @param {string} [message] The error message. This will override the default
 *     message if provided.
 * @constructor
 */
var FirebaseFirestoreError = /** @class */ (function (_super) {
    __extends(FirebaseFirestoreError, _super);
    function FirebaseFirestoreError(info, message) {
        // Override default message if custom message provided.
        return _super.call(this, { code: 'firestore/' + info.code, message: message || info.message }) || this;
    }
    return FirebaseFirestoreError;
}(FirebaseError));
exports.FirebaseFirestoreError = FirebaseFirestoreError;
/**
 * Firebase instance ID error code structure. This extends FirebaseError.
 *
 * @param {ErrorInfo} info The error code info.
 * @param {string} [message] The error message. This will override the default
 *     message if provided.
 * @constructor
 */
var FirebaseInstanceIdError = /** @class */ (function (_super) {
    __extends(FirebaseInstanceIdError, _super);
    function FirebaseInstanceIdError(info, message) {
        // Override default message if custom message provided.
        return _super.call(this, { code: 'instance-id/' + info.code, message: message || info.message }) || this;
    }
    return FirebaseInstanceIdError;
}(FirebaseError));
exports.FirebaseInstanceIdError = FirebaseInstanceIdError;
/**
 * Firebase Messaging error code structure. This extends PrefixedFirebaseError.
 *
 * @param {ErrorInfo} info The error code info.
 * @param {string} [message] The error message. This will override the default message if provided.
 * @constructor
 */
var FirebaseMessagingError = /** @class */ (function (_super) {
    __extends(FirebaseMessagingError, _super);
    function FirebaseMessagingError(info, message) {
        var _this = 
        // Override default message if custom message provided.
        _super.call(this, 'messaging', info.code, message || info.message) || this;
        /* tslint:disable:max-line-length */
        // Set the prototype explicitly. See the following link for more details:
        // https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work
        /* tslint:enable:max-line-length */
        _this.__proto__ = FirebaseMessagingError.prototype;
        return _this;
    }
    /**
     * Creates the developer-facing error corresponding to the backend error code.
     *
     * @param {string} serverErrorCode The server error code.
     * @param {string} [message] The error message. The default message is used
     *     if not provided.
     * @param {object} [rawServerResponse] The error's raw server response.
     * @return {FirebaseMessagingError} The corresponding developer-facing error.
     */
    FirebaseMessagingError.fromServerError = function (serverErrorCode, message, rawServerResponse) {
        // If not found, default to unknown error.
        var clientCodeKey = MESSAGING_SERVER_TO_CLIENT_CODE[serverErrorCode] || 'UNKNOWN_ERROR';
        var error = deep_copy_1.deepCopy(MessagingClientErrorCode[clientCodeKey]);
        error.message = message || error.message;
        if (clientCodeKey === 'UNKNOWN_ERROR' && typeof rawServerResponse !== 'undefined') {
            try {
                error.message += " Raw server response: \"" + JSON.stringify(rawServerResponse) + "\"";
            }
            catch (e) {
                // Ignore JSON parsing error.
            }
        }
        return new FirebaseMessagingError(error);
    };
    FirebaseMessagingError.fromTopicManagementServerError = function (serverErrorCode, message, rawServerResponse) {
        // If not found, default to unknown error.
        var clientCodeKey = TOPIC_MGT_SERVER_TO_CLIENT_CODE[serverErrorCode] || 'UNKNOWN_ERROR';
        var error = deep_copy_1.deepCopy(MessagingClientErrorCode[clientCodeKey]);
        error.message = message || error.message;
        if (clientCodeKey === 'UNKNOWN_ERROR' && typeof rawServerResponse !== 'undefined') {
            try {
                error.message += " Raw server response: \"" + JSON.stringify(rawServerResponse) + "\"";
            }
            catch (e) {
                // Ignore JSON parsing error.
            }
        }
        return new FirebaseMessagingError(error);
    };
    return FirebaseMessagingError;
}(PrefixedFirebaseError));
exports.FirebaseMessagingError = FirebaseMessagingError;
/**
 * App client error codes and their default messages.
 */
var AppErrorCodes = /** @class */ (function () {
    function AppErrorCodes() {
    }
    AppErrorCodes.APP_DELETED = 'app-deleted';
    AppErrorCodes.DUPLICATE_APP = 'duplicate-app';
    AppErrorCodes.INTERNAL_ERROR = 'internal-error';
    AppErrorCodes.INVALID_APP_NAME = 'invalid-app-name';
    AppErrorCodes.INVALID_APP_OPTIONS = 'invalid-app-options';
    AppErrorCodes.INVALID_CREDENTIAL = 'invalid-credential';
    AppErrorCodes.NETWORK_ERROR = 'network-error';
    AppErrorCodes.NETWORK_TIMEOUT = 'network-timeout';
    AppErrorCodes.NO_APP = 'no-app';
    AppErrorCodes.UNABLE_TO_PARSE_RESPONSE = 'unable-to-parse-response';
    return AppErrorCodes;
}());
exports.AppErrorCodes = AppErrorCodes;
/**
 * Auth client error codes and their default messages.
 */
var AuthClientErrorCode = /** @class */ (function () {
    function AuthClientErrorCode() {
    }
    AuthClientErrorCode.CLAIMS_TOO_LARGE = {
        code: 'claims-too-large',
        message: 'Developer claims maximum payload size exceeded.',
    };
    AuthClientErrorCode.ID_TOKEN_EXPIRED = {
        code: 'id-token-expired',
        message: 'The provided Firebase ID token is expired.',
    };
    AuthClientErrorCode.INVALID_ARGUMENT = {
        code: 'argument-error',
        message: 'Invalid argument provided.',
    };
    AuthClientErrorCode.EMAIL_ALREADY_EXISTS = {
        code: 'email-already-exists',
        message: 'The email address is already in use by another account.',
    };
    AuthClientErrorCode.FORBIDDEN_CLAIM = {
        code: 'reserved-claim',
        message: 'The specified developer claim is reserved and cannot be specified.',
    };
    AuthClientErrorCode.INVALID_ID_TOKEN = {
        code: 'invalid-id-token',
        message: 'The provided ID token is not a valid Firebase ID token.',
    };
    AuthClientErrorCode.ID_TOKEN_REVOKED = {
        code: 'id-token-revoked',
        message: 'The Firebase ID token has been revoked.',
    };
    AuthClientErrorCode.INTERNAL_ERROR = {
        code: 'internal-error',
        message: 'An internal error has occurred.',
    };
    AuthClientErrorCode.INVALID_CLAIMS = {
        code: 'invalid-claims',
        message: 'The provided custom claim attributes are invalid.',
    };
    AuthClientErrorCode.INVALID_CREATION_TIME = {
        code: 'invalid-creation-time',
        message: 'The creation time must be a valid UTC date string.',
    };
    AuthClientErrorCode.INVALID_CREDENTIAL = {
        code: 'invalid-credential',
        message: 'Invalid credential object provided.',
    };
    AuthClientErrorCode.INVALID_DISABLED_FIELD = {
        code: 'invalid-disabled-field',
        message: 'The disabled field must be a boolean.',
    };
    AuthClientErrorCode.INVALID_DISPLAY_NAME = {
        code: 'invalid-display-name',
        message: 'The displayName field must be a valid string.',
    };
    AuthClientErrorCode.INVALID_EMAIL_VERIFIED = {
        code: 'invalid-email-verified',
        message: 'The emailVerified field must be a boolean.',
    };
    AuthClientErrorCode.INVALID_EMAIL = {
        code: 'invalid-email',
        message: 'The email address is improperly formatted.',
    };
    AuthClientErrorCode.INVALID_HASH_ALGORITHM = {
        code: 'invalid-hash-algorithm',
        message: 'The hash algorithm must match one of the strings in the list of ' +
            'supported algorithms.',
    };
    AuthClientErrorCode.INVALID_HASH_BLOCK_SIZE = {
        code: 'invalid-hash-block-size',
        message: 'The hash block size must be a valid number.',
    };
    AuthClientErrorCode.INVALID_HASH_DERIVED_KEY_LENGTH = {
        code: 'invalid-hash-derived-key-length',
        message: 'The hash derived key length must be a valid number.',
    };
    AuthClientErrorCode.INVALID_HASH_KEY = {
        code: 'invalid-hash-key',
        message: 'The hash key must a valid byte buffer.',
    };
    AuthClientErrorCode.INVALID_HASH_MEMORY_COST = {
        code: 'invalid-hash-memory-cost',
        message: 'The hash memory cost must be a valid number.',
    };
    AuthClientErrorCode.INVALID_HASH_PARALLELIZATION = {
        code: 'invalid-hash-parallelization',
        message: 'The hash parallelization must be a valid number.',
    };
    AuthClientErrorCode.INVALID_HASH_ROUNDS = {
        code: 'invalid-hash-rounds',
        message: 'The hash rounds must be a valid number.',
    };
    AuthClientErrorCode.INVALID_HASH_SALT_SEPARATOR = {
        code: 'invalid-hash-salt-separator',
        message: 'The hashing algorithm salt separator field must be a valid byte buffer.',
    };
    AuthClientErrorCode.INVALID_LAST_SIGN_IN_TIME = {
        code: 'invalid-last-sign-in-time',
        message: 'The last sign-in time must be a valid UTC date string.',
    };
    AuthClientErrorCode.INVALID_PAGE_TOKEN = {
        code: 'invalid-page-token',
        message: 'The page token must be a valid non-empty string.',
    };
    AuthClientErrorCode.INVALID_PASSWORD = {
        code: 'invalid-password',
        message: 'The password must be a string with at least 6 characters.',
    };
    AuthClientErrorCode.INVALID_PASSWORD_HASH = {
        code: 'invalid-password-hash',
        message: 'The password hash must be a valid byte buffer.',
    };
    AuthClientErrorCode.INVALID_PASSWORD_SALT = {
        code: 'invalid-password-salt',
        message: 'The password salt must be a valid byte buffer.',
    };
    AuthClientErrorCode.INVALID_PHONE_NUMBER = {
        code: 'invalid-phone-number',
        message: 'The phone number must be a non-empty E.164 standard compliant identifier ' +
            'string.',
    };
    AuthClientErrorCode.INVALID_PHOTO_URL = {
        code: 'invalid-photo-url',
        message: 'The photoURL field must be a valid URL.',
    };
    AuthClientErrorCode.INVALID_PROVIDER_DATA = {
        code: 'invalid-provider-data',
        message: 'The providerData must be a valid array of UserInfo objects.',
    };
    AuthClientErrorCode.INVALID_PROVIDER_ID = {
        code: 'invalid-provider-id',
        message: 'The providerId must be a valid supported provider identifier string.',
    };
    AuthClientErrorCode.INVALID_SESSION_COOKIE_DURATION = {
        code: 'invalid-session-cookie-duration',
        message: 'The session cookie duration must be a valid number in milliseconds ' +
            'between 5 minutes and 2 weeks.',
    };
    AuthClientErrorCode.INVALID_UID = {
        code: 'invalid-uid',
        message: 'The uid must be a non-empty string with at most 128 characters.',
    };
    AuthClientErrorCode.INVALID_USER_IMPORT = {
        code: 'invalid-user-import',
        message: 'The user record to import is invalid.',
    };
    AuthClientErrorCode.INVALID_TOKENS_VALID_AFTER_TIME = {
        code: 'invalid-tokens-valid-after-time',
        message: 'The tokensValidAfterTime must be a valid UTC number in seconds.',
    };
    AuthClientErrorCode.MISSING_HASH_ALGORITHM = {
        code: 'missing-hash-algorithm',
        message: 'Importing users with password hashes requires that the hashing ' +
            'algorithm and its parameters be provided.',
    };
    AuthClientErrorCode.MAXIMUM_USER_COUNT_EXCEEDED = {
        code: 'maximum-user-count-exceeded',
        message: 'The maximum allowed number of users to import has been exceeded.',
    };
    AuthClientErrorCode.MISSING_UID = {
        code: 'missing-uid',
        message: 'A uid identifier is required for the current operation.',
    };
    AuthClientErrorCode.OPERATION_NOT_ALLOWED = {
        code: 'operation-not-allowed',
        message: '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.',
    };
    AuthClientErrorCode.PHONE_NUMBER_ALREADY_EXISTS = {
        code: 'phone-number-already-exists',
        message: 'The user with the provided phone number already exists.',
    };
    AuthClientErrorCode.PROJECT_NOT_FOUND = {
        code: 'project-not-found',
        message: 'No Firebase project was found for the provided credential.',
    };
    AuthClientErrorCode.INSUFFICIENT_PERMISSION = {
        code: 'insufficient-permission',
        message: 'Credential implementation provided to initializeApp() via the "credential" property ' +
            'has insufficient permission to access the requested resource. See ' +
            'https://firebase.google.com/docs/admin/setup for details on how to authenticate this SDK ' +
            'with appropriate permissions.',
    };
    AuthClientErrorCode.SESSION_COOKIE_REVOKED = {
        code: 'session-cookie-revoked',
        message: 'The Firebase session cookie has been revoked.',
    };
    AuthClientErrorCode.UID_ALREADY_EXISTS = {
        code: 'uid-already-exists',
        message: 'The user with the provided uid already exists.',
    };
    AuthClientErrorCode.USER_NOT_FOUND = {
        code: 'user-not-found',
        message: 'There is no user record corresponding to the provided identifier.',
    };
    return AuthClientErrorCode;
}());
exports.AuthClientErrorCode = AuthClientErrorCode;
/**
 * Messaging client error codes and their default messages.
 */
var MessagingClientErrorCode = /** @class */ (function () {
    function MessagingClientErrorCode() {
    }
    MessagingClientErrorCode.INVALID_ARGUMENT = {
        code: 'invalid-argument',
        message: 'Invalid argument provided.',
    };
    MessagingClientErrorCode.INVALID_RECIPIENT = {
        code: 'invalid-recipient',
        message: 'Invalid message recipient provided.',
    };
    MessagingClientErrorCode.INVALID_PAYLOAD = {
        code: 'invalid-payload',
        message: 'Invalid message payload provided.',
    };
    MessagingClientErrorCode.INVALID_DATA_PAYLOAD_KEY = {
        code: 'invalid-data-payload-key',
        message: 'The data message payload contains an invalid key. See the reference documentation ' +
            'for the DataMessagePayload type for restricted keys.',
    };
    MessagingClientErrorCode.PAYLOAD_SIZE_LIMIT_EXCEEDED = {
        code: 'payload-size-limit-exceeded',
        message: 'The provided message payload exceeds the FCM size limits. See the error documentation ' +
            'for more details.',
    };
    MessagingClientErrorCode.INVALID_OPTIONS = {
        code: 'invalid-options',
        message: 'Invalid message options provided.',
    };
    MessagingClientErrorCode.INVALID_REGISTRATION_TOKEN = {
        code: 'invalid-registration-token',
        message: 'Invalid registration token provided. Make sure it matches the registration token ' +
            'the client app receives from registering with FCM.',
    };
    MessagingClientErrorCode.REGISTRATION_TOKEN_NOT_REGISTERED = {
        code: 'registration-token-not-registered',
        message: 'The provided registration token is not registered. A previously valid registration ' +
            'token can be unregistered for a variety of reasons. See the error documentation for more ' +
            'details. Remove this registration token and stop using it to send messages.',
    };
    MessagingClientErrorCode.MISMATCHED_CREDENTIAL = {
        code: 'mismatched-credential',
        message: 'The credential used to authenticate this SDK does not have permission to send ' +
            'messages to the device corresponding to the provided registration token. Make sure the ' +
            'credential and registration token both belong to the same Firebase project.',
    };
    MessagingClientErrorCode.INVALID_PACKAGE_NAME = {
        code: 'invalid-package-name',
        message: 'The message was addressed to a registration token whose package name does not match ' +
            'the provided "restrictedPackageName" option.',
    };
    MessagingClientErrorCode.DEVICE_MESSAGE_RATE_EXCEEDED = {
        code: 'device-message-rate-exceeded',
        message: 'The rate of messages to a particular device is too high. Reduce the number of ' +
            'messages sent to this device and do not immediately retry sending to this device.',
    };
    MessagingClientErrorCode.TOPICS_MESSAGE_RATE_EXCEEDED = {
        code: 'topics-message-rate-exceeded',
        message: 'The rate of messages to subscribers to a particular topic is too high. Reduce the ' +
            'number of messages sent for this topic, and do not immediately retry sending to this topic.',
    };
    MessagingClientErrorCode.MESSAGE_RATE_EXCEEDED = {
        code: 'message-rate-exceeded',
        message: 'Sending limit exceeded for the message target.',
    };
    MessagingClientErrorCode.INVALID_APNS_CREDENTIALS = {
        code: 'invalid-apns-credentials',
        message: 'A message targeted to an iOS device could not be sent because the required APNs ' +
            'SSL certificate was not uploaded or has expired. Check the validity of your development ' +
            'and production certificates.',
    };
    MessagingClientErrorCode.TOO_MANY_TOPICS = {
        code: 'too-many-topics',
        message: 'The maximum number of topics the provided registration token can be subscribed to ' +
            'has been exceeded.',
    };
    MessagingClientErrorCode.AUTHENTICATION_ERROR = {
        code: 'authentication-error',
        message: 'An error occurred when trying to authenticate to the FCM servers. Make sure the ' +
            'credential used to authenticate this SDK has the proper permissions. See ' +
            'https://firebase.google.com/docs/admin/setup for setup instructions.',
    };
    MessagingClientErrorCode.SERVER_UNAVAILABLE = {
        code: 'server-unavailable',
        message: 'The FCM server could not process the request in time. See the error documentation ' +
            'for more details.',
    };
    MessagingClientErrorCode.INTERNAL_ERROR = {
        code: 'internal-error',
        message: 'An internal error has occurred. Please retry the request.',
    };
    MessagingClientErrorCode.UNKNOWN_ERROR = {
        code: 'unknown-error',
        message: 'An unknown server error was returned.',
    };
    return MessagingClientErrorCode;
}());
exports.MessagingClientErrorCode = MessagingClientErrorCode;
var InstanceIdClientErrorCode = /** @class */ (function () {
    function InstanceIdClientErrorCode() {
    }
    InstanceIdClientErrorCode.INVALID_ARGUMENT = {
        code: 'invalid-argument',
        message: 'Invalid argument provided.',
    };
    InstanceIdClientErrorCode.INVALID_PROJECT_ID = {
        code: 'invalid-project-id',
        message: 'Invalid project ID provided.',
    };
    InstanceIdClientErrorCode.INVALID_INSTANCE_ID = {
        code: 'invalid-instance-id',
        message: 'Invalid instance ID provided.',
    };
    InstanceIdClientErrorCode.API_ERROR = {
        code: 'api-error',
        message: 'Instance ID API call failed.',
    };
    return InstanceIdClientErrorCode;
}());
exports.InstanceIdClientErrorCode = InstanceIdClientErrorCode;
/** @const {ServerToClientCode} Auth server to client enum error codes. */
var AUTH_SERVER_TO_CLIENT_CODE = {
    // Claims payload is too large.
    CLAIMS_TOO_LARGE: 'CLAIMS_TOO_LARGE',
    // Project not found.
    CONFIGURATION_NOT_FOUND: 'PROJECT_NOT_FOUND',
    // Provided credential has insufficient permissions.
    INSUFFICIENT_PERMISSION: 'INSUFFICIENT_PERMISSION',
    // uploadAccount provides an email that already exists.
    DUPLICATE_EMAIL: 'EMAIL_ALREADY_EXISTS',
    // uploadAccount provides a localId that already exists.
    DUPLICATE_LOCAL_ID: 'UID_ALREADY_EXISTS',
    // setAccountInfo email already exists.
    EMAIL_EXISTS: 'EMAIL_ALREADY_EXISTS',
    // Reserved claim name.
    FORBIDDEN_CLAIM: 'FORBIDDEN_CLAIM',
    // Invalid claims provided.
    INVALID_CLAIMS: 'INVALID_CLAIMS',
    // Invalid session cookie duration.
    INVALID_DURATION: 'INVALID_SESSION_COOKIE_DURATION',
    // Invalid email provided.
    INVALID_EMAIL: 'INVALID_EMAIL',
    // Invalid ID token provided.
    INVALID_ID_TOKEN: 'INVALID_ID_TOKEN',
    // Invalid page token.
    INVALID_PAGE_SELECTION: 'INVALID_PAGE_TOKEN',
    // Invalid phone number.
    INVALID_PHONE_NUMBER: 'INVALID_PHONE_NUMBER',
    // Invalid service account.
    INVALID_SERVICE_ACCOUNT: 'INVALID_SERVICE_ACCOUNT',
    // No localId provided (deleteAccount missing localId).
    MISSING_LOCAL_ID: 'MISSING_UID',
    // Empty user list in uploadAccount.
    MISSING_USER_ACCOUNT: 'MISSING_UID',
    // Password auth disabled in console.
    OPERATION_NOT_ALLOWED: 'OPERATION_NOT_ALLOWED',
    // Provided credential has insufficient permissions.
    PERMISSION_DENIED: 'INSUFFICIENT_PERMISSION',
    // Phone number already exists.
    PHONE_NUMBER_EXISTS: 'PHONE_NUMBER_ALREADY_EXISTS',
    // Project not found.
    PROJECT_NOT_FOUND: 'PROJECT_NOT_FOUND',
    // Token expired error.
    TOKEN_EXPIRED: 'ID_TOKEN_EXPIRED',
    // User on which action is to be performed is not found.
    USER_NOT_FOUND: 'USER_NOT_FOUND',
    // Password provided is too weak.
    WEAK_PASSWORD: 'INVALID_PASSWORD',
};
/** @const {ServerToClientCode} Messaging server to client enum error codes. */
var MESSAGING_SERVER_TO_CLIENT_CODE = {
    /* GENERIC ERRORS */
    // Generic invalid message parameter provided.
    InvalidParameters: 'INVALID_ARGUMENT',
    // Mismatched sender ID.
    MismatchSenderId: 'MISMATCHED_CREDENTIAL',
    // FCM server unavailable.
    Unavailable: 'SERVER_UNAVAILABLE',
    // FCM server internal error.
    InternalServerError: 'INTERNAL_ERROR',
    /* SEND ERRORS */
    // Invalid registration token format.
    InvalidRegistration: 'INVALID_REGISTRATION_TOKEN',
    // Registration token is not registered.
    NotRegistered: 'REGISTRATION_TOKEN_NOT_REGISTERED',
    // Registration token does not match restricted package name.
    InvalidPackageName: 'INVALID_PACKAGE_NAME',
    // Message payload size limit exceeded.
    MessageTooBig: 'PAYLOAD_SIZE_LIMIT_EXCEEDED',
    // Invalid key in the data message payload.
    InvalidDataKey: 'INVALID_DATA_PAYLOAD_KEY',
    // Invalid time to live option.
    InvalidTtl: 'INVALID_OPTIONS',
    // Device message rate exceeded.
    DeviceMessageRateExceeded: 'DEVICE_MESSAGE_RATE_EXCEEDED',
    // Topics message rate exceeded.
    TopicsMessageRateExceeded: 'TOPICS_MESSAGE_RATE_EXCEEDED',
    // Invalid APNs credentials.
    InvalidApnsCredential: 'INVALID_APNS_CREDENTIALS',
    /* FCM v1 canonical error codes */
    NOT_FOUND: 'REGISTRATION_TOKEN_NOT_REGISTERED',
    PERMISSION_DENIED: 'MISMATCHED_CREDENTIAL',
    RESOURCE_EXHAUSTED: 'MESSAGE_RATE_EXCEEDED',
    UNAUTHENTICATED: 'INVALID_APNS_CREDENTIALS',
    /* FCM v1 new error codes */
    APNS_AUTH_ERROR: 'INVALID_APNS_CREDENTIALS',
    INTERNAL: 'INTERNAL_ERROR',
    INVALID_ARGUMENT: 'INVALID_ARGUMENT',
    QUOTA_EXCEEDED: 'MESSAGE_RATE_EXCEEDED',
    SENDER_ID_MISMATCH: 'MISMATCHED_CREDENTIAL',
    UNAVAILABLE: 'SERVER_UNAVAILABLE',
    UNREGISTERED: 'REGISTRATION_TOKEN_NOT_REGISTERED',
    UNSPECIFIED_ERROR: 'UNKNOWN_ERROR',
};
/** @const {ServerToClientCode} Topic management (IID) server to client enum error codes. */
var TOPIC_MGT_SERVER_TO_CLIENT_CODE = {
    /* TOPIC SUBSCRIPTION MANAGEMENT ERRORS */
    NOT_FOUND: 'REGISTRATION_TOKEN_NOT_REGISTERED',
    INVALID_ARGUMENT: 'INVALID_REGISTRATION_TOKEN',
    TOO_MANY_TOPICS: 'TOO_MANY_TOPICS',
    RESOURCE_EXHAUSTED: 'TOO_MANY_TOPICS',
    PERMISSION_DENIED: 'AUTHENTICATION_ERROR',
    DEADLINE_EXCEEDED: 'SERVER_UNAVAILABLE',
    INTERNAL: 'INTERNAL_ERROR',
    UNKNOWN: 'UNKNOWN_ERROR',
};