mirror of
https://github.com/musix-org/musix-oss
synced 2024-12-23 22:33:17 +00:00
943 lines
41 KiB
JavaScript
943 lines
41 KiB
JavaScript
/*! firebase-admin v8.9.2 */
|
|
"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 = function (d, b) {
|
|
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 extendStatics(d, b);
|
|
};
|
|
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));
|
|
exports.PrefixedFirebaseError = PrefixedFirebaseError;
|
|
/**
|
|
* 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) {
|
|
// serverErrorCode could contain additional details:
|
|
// ERROR_CODE : Detailed message which can also contain colons
|
|
var colonSeparator = (serverErrorCode || '').indexOf(':');
|
|
var customMessage = null;
|
|
if (colonSeparator !== -1) {
|
|
customMessage = serverErrorCode.substring(colonSeparator + 1).trim();
|
|
serverErrorCode = serverErrorCode.substring(0, colonSeparator).trim();
|
|
}
|
|
// 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]);
|
|
// Server detailed message should have highest priority.
|
|
error.message = customMessage || 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 = 'UNKNOWN_ERROR';
|
|
if (serverErrorCode && serverErrorCode in MESSAGING_SERVER_TO_CLIENT_CODE) {
|
|
clientCodeKey = MESSAGING_SERVER_TO_CLIENT_CODE[serverErrorCode];
|
|
}
|
|
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;
|
|
/**
|
|
* Firebase project management error code structure. This extends PrefixedFirebaseError.
|
|
*
|
|
* @param {ProjectManagementErrorCode} code The error code.
|
|
* @param {string} message The error message.
|
|
* @constructor
|
|
*/
|
|
var FirebaseProjectManagementError = /** @class */ (function (_super) {
|
|
__extends(FirebaseProjectManagementError, _super);
|
|
function FirebaseProjectManagementError(code, message) {
|
|
var _this = _super.call(this, 'project-management', 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__ = FirebaseProjectManagementError.prototype;
|
|
return _this;
|
|
}
|
|
return FirebaseProjectManagementError;
|
|
}(PrefixedFirebaseError));
|
|
exports.FirebaseProjectManagementError = FirebaseProjectManagementError;
|
|
/**
|
|
* 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.INVALID_ARGUMENT = 'invalid-argument';
|
|
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.BILLING_NOT_ENABLED = {
|
|
code: 'billing-not-enabled',
|
|
message: 'Feature requires billing to be enabled.',
|
|
};
|
|
AuthClientErrorCode.CLAIMS_TOO_LARGE = {
|
|
code: 'claims-too-large',
|
|
message: 'Developer claims maximum payload size exceeded.',
|
|
};
|
|
AuthClientErrorCode.CONFIGURATION_EXISTS = {
|
|
code: 'configuration-exists',
|
|
message: 'A configuration already exists with the provided identifier.',
|
|
};
|
|
AuthClientErrorCode.CONFIGURATION_NOT_FOUND = {
|
|
code: 'configuration-not-found',
|
|
message: 'There is no configuration corresponding to the provided identifier.',
|
|
};
|
|
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.INVALID_CONFIG = {
|
|
code: 'invalid-config',
|
|
message: 'The provided configuration is invalid.',
|
|
};
|
|
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_CONTINUE_URI = {
|
|
code: 'invalid-continue-uri',
|
|
message: 'The continue URL must be a valid URL string.',
|
|
};
|
|
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_DYNAMIC_LINK_DOMAIN = {
|
|
code: 'invalid-dynamic-link-domain',
|
|
message: 'The provided dynamic link domain is not configured or authorized ' +
|
|
'for the current project.',
|
|
};
|
|
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_NAME = {
|
|
code: 'invalid-name',
|
|
message: 'The resource name provided is invalid.',
|
|
};
|
|
AuthClientErrorCode.INVALID_OAUTH_CLIENT_ID = {
|
|
code: 'invalid-oauth-client-id',
|
|
message: 'The provided OAuth client ID is invalid.',
|
|
};
|
|
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_PROJECT_ID = {
|
|
code: 'invalid-project-id',
|
|
message: 'Invalid parent project. Either parent project doesn\'t exist or didn\'t enable multi-tenancy.',
|
|
};
|
|
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_TENANT_ID = {
|
|
code: 'invalid-tenant-id',
|
|
message: 'The tenant ID must be a valid non-empty string.',
|
|
};
|
|
AuthClientErrorCode.INVALID_TENANT_TYPE = {
|
|
code: 'invalid-tenant-type',
|
|
message: 'Tenant type must be either "full_service" or "lightweight".',
|
|
};
|
|
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.MISMATCHING_TENANT_ID = {
|
|
code: 'mismatching-tenant-id',
|
|
message: 'User tenant ID does not match with the current TenantAwareAuth tenant ID.',
|
|
};
|
|
AuthClientErrorCode.MISSING_ANDROID_PACKAGE_NAME = {
|
|
code: 'missing-android-pkg-name',
|
|
message: 'An Android Package Name must be provided if the Android App is ' +
|
|
'required to be installed.',
|
|
};
|
|
AuthClientErrorCode.MISSING_CONFIG = {
|
|
code: 'missing-config',
|
|
message: 'The provided configuration is missing required attributes.',
|
|
};
|
|
AuthClientErrorCode.MISSING_CONTINUE_URI = {
|
|
code: 'missing-continue-uri',
|
|
message: 'A valid continue URL must be provided in the request.',
|
|
};
|
|
AuthClientErrorCode.MISSING_DISPLAY_NAME = {
|
|
code: 'missing-display-name',
|
|
message: 'The resource being created or edited is missing a valid display name.',
|
|
};
|
|
AuthClientErrorCode.MISSING_IOS_BUNDLE_ID = {
|
|
code: 'missing-ios-bundle-id',
|
|
message: 'The request is missing an iOS Bundle ID.',
|
|
};
|
|
AuthClientErrorCode.MISSING_ISSUER = {
|
|
code: 'missing-issuer',
|
|
message: 'The OAuth/OIDC configuration issuer must not be empty.',
|
|
};
|
|
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.MISSING_OAUTH_CLIENT_ID = {
|
|
code: 'missing-oauth-client-id',
|
|
message: 'The OAuth/OIDC configuration client ID must not be empty.',
|
|
};
|
|
AuthClientErrorCode.MISSING_PROVIDER_ID = {
|
|
code: 'missing-provider-id',
|
|
message: 'A valid provider ID must be provided in the request.',
|
|
};
|
|
AuthClientErrorCode.MISSING_SAML_RELYING_PARTY_CONFIG = {
|
|
code: 'missing-saml-relying-party-config',
|
|
message: 'The SAML configuration provided is missing a relying party configuration.',
|
|
};
|
|
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.QUOTA_EXCEEDED = {
|
|
code: 'quota-exceeded',
|
|
message: 'The project quota for the specified operation has been exceeded.',
|
|
};
|
|
AuthClientErrorCode.SESSION_COOKIE_EXPIRED = {
|
|
code: 'session-cookie-expired',
|
|
message: 'The Firebase session cookie is expired.',
|
|
};
|
|
AuthClientErrorCode.SESSION_COOKIE_REVOKED = {
|
|
code: 'session-cookie-revoked',
|
|
message: 'The Firebase session cookie has been revoked.',
|
|
};
|
|
AuthClientErrorCode.TENANT_NOT_FOUND = {
|
|
code: 'tenant-not-found',
|
|
message: 'There is no tenant corresponding to the provided identifier.',
|
|
};
|
|
AuthClientErrorCode.UID_ALREADY_EXISTS = {
|
|
code: 'uid-already-exists',
|
|
message: 'The user with the provided uid already exists.',
|
|
};
|
|
AuthClientErrorCode.UNAUTHORIZED_DOMAIN = {
|
|
code: 'unauthorized-continue-uri',
|
|
message: 'The domain of the continue URL is not whitelisted. Whitelist the domain in the ' +
|
|
'Firebase console.',
|
|
};
|
|
AuthClientErrorCode.UNSUPPORTED_TENANT_OPERATION = {
|
|
code: 'unsupported-tenant-operation',
|
|
message: 'This operation is not supported in a multi-tenant context.',
|
|
};
|
|
AuthClientErrorCode.USER_NOT_FOUND = {
|
|
code: 'user-not-found',
|
|
message: 'There is no user record corresponding to the provided identifier.',
|
|
};
|
|
AuthClientErrorCode.NOT_FOUND = {
|
|
code: 'not-found',
|
|
message: 'The requested resource was not found.',
|
|
};
|
|
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.THIRD_PARTY_AUTH_ERROR = {
|
|
code: 'third-party-auth-error',
|
|
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 = {
|
|
// Feature being configured or used requires a billing account.
|
|
BILLING_NOT_ENABLED: 'BILLING_NOT_ENABLED',
|
|
// Claims payload is too large.
|
|
CLAIMS_TOO_LARGE: 'CLAIMS_TOO_LARGE',
|
|
// Configuration being added already exists.
|
|
CONFIGURATION_EXISTS: 'CONFIGURATION_EXISTS',
|
|
// Configuration not found.
|
|
CONFIGURATION_NOT_FOUND: 'CONFIGURATION_NOT_FOUND',
|
|
// Provided credential has insufficient permissions.
|
|
INSUFFICIENT_PERMISSION: 'INSUFFICIENT_PERMISSION',
|
|
// Provided configuration has invalid fields.
|
|
INVALID_CONFIG: 'INVALID_CONFIG',
|
|
// Provided configuration identifier is invalid.
|
|
INVALID_CONFIG_ID: 'INVALID_PROVIDER_ID',
|
|
// ActionCodeSettings missing continue URL.
|
|
INVALID_CONTINUE_URI: 'INVALID_CONTINUE_URI',
|
|
// Dynamic link domain in provided ActionCodeSettings is not authorized.
|
|
INVALID_DYNAMIC_LINK_DOMAIN: 'INVALID_DYNAMIC_LINK_DOMAIN',
|
|
// 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 tenant display name. This can be thrown on CreateTenant and UpdateTenant.
|
|
INVALID_DISPLAY_NAME: 'INVALID_DISPLAY_NAME',
|
|
// Invalid ID token provided.
|
|
INVALID_ID_TOKEN: 'INVALID_ID_TOKEN',
|
|
// Invalid tenant/parent resource name.
|
|
INVALID_NAME: 'INVALID_NAME',
|
|
// OIDC configuration has an invalid OAuth client ID.
|
|
INVALID_OAUTH_CLIENT_ID: 'INVALID_OAUTH_CLIENT_ID',
|
|
// Invalid page token.
|
|
INVALID_PAGE_SELECTION: 'INVALID_PAGE_TOKEN',
|
|
// Invalid phone number.
|
|
INVALID_PHONE_NUMBER: 'INVALID_PHONE_NUMBER',
|
|
// Invalid agent project. Either agent project doesn't exist or didn't enable multi-tenancy.
|
|
INVALID_PROJECT_ID: 'INVALID_PROJECT_ID',
|
|
// Invalid provider ID.
|
|
INVALID_PROVIDER_ID: 'INVALID_PROVIDER_ID',
|
|
// Invalid service account.
|
|
INVALID_SERVICE_ACCOUNT: 'INVALID_SERVICE_ACCOUNT',
|
|
// Invalid tenant type.
|
|
INVALID_TENANT_TYPE: 'INVALID_TENANT_TYPE',
|
|
// Missing Android package name.
|
|
MISSING_ANDROID_PACKAGE_NAME: 'MISSING_ANDROID_PACKAGE_NAME',
|
|
// Missing configuration.
|
|
MISSING_CONFIG: 'MISSING_CONFIG',
|
|
// Missing configuration identifier.
|
|
MISSING_CONFIG_ID: 'MISSING_PROVIDER_ID',
|
|
// Missing tenant display name: This can be thrown on CreateTenant and UpdateTenant.
|
|
MISSING_DISPLAY_NAME: 'MISSING_DISPLAY_NAME',
|
|
// Missing iOS bundle ID.
|
|
MISSING_IOS_BUNDLE_ID: 'MISSING_IOS_BUNDLE_ID',
|
|
// Missing OIDC issuer.
|
|
MISSING_ISSUER: 'MISSING_ISSUER',
|
|
// No localId provided (deleteAccount missing localId).
|
|
MISSING_LOCAL_ID: 'MISSING_UID',
|
|
// OIDC configuration is missing an OAuth client ID.
|
|
MISSING_OAUTH_CLIENT_ID: 'MISSING_OAUTH_CLIENT_ID',
|
|
// Missing provider ID.
|
|
MISSING_PROVIDER_ID: 'MISSING_PROVIDER_ID',
|
|
// Missing SAML RP config.
|
|
MISSING_SAML_RELYING_PARTY_CONFIG: 'MISSING_SAML_RELYING_PARTY_CONFIG',
|
|
// 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',
|
|
// In multi-tenancy context: project creation quota exceeded.
|
|
QUOTA_EXCEEDED: 'QUOTA_EXCEEDED',
|
|
// Tenant not found.
|
|
TENANT_NOT_FOUND: 'TENANT_NOT_FOUND',
|
|
// Tenant ID mismatch.
|
|
TENANT_ID_MISMATCH: 'MISMATCHING_TENANT_ID',
|
|
// Token expired error.
|
|
TOKEN_EXPIRED: 'ID_TOKEN_EXPIRED',
|
|
// Continue URL provided in ActionCodeSettings has a domain that is not whitelisted.
|
|
UNAUTHORIZED_DOMAIN: 'UNAUTHORIZED_DOMAIN',
|
|
// Operation is not supported in a multi-tenant context.
|
|
UNSUPPORTED_TENANT_OPERATION: 'UNSUPPORTED_TENANT_OPERATION',
|
|
// 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: 'THIRD_PARTY_AUTH_ERROR',
|
|
/* FCM v1 canonical error codes */
|
|
NOT_FOUND: 'REGISTRATION_TOKEN_NOT_REGISTERED',
|
|
PERMISSION_DENIED: 'MISMATCHED_CREDENTIAL',
|
|
RESOURCE_EXHAUSTED: 'MESSAGE_RATE_EXCEEDED',
|
|
UNAUTHENTICATED: 'THIRD_PARTY_AUTH_ERROR',
|
|
/* FCM v1 new error codes */
|
|
APNS_AUTH_ERROR: 'THIRD_PARTY_AUTH_ERROR',
|
|
INTERNAL: 'INTERNAL_ERROR',
|
|
INVALID_ARGUMENT: 'INVALID_ARGUMENT',
|
|
QUOTA_EXCEEDED: 'MESSAGE_RATE_EXCEEDED',
|
|
SENDER_ID_MISMATCH: 'MISMATCHED_CREDENTIAL',
|
|
THIRD_PARTY_AUTH_ERROR: 'THIRD_PARTY_AUTH_ERROR',
|
|
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',
|
|
};
|