firebase-admin

  • Version 10.0.0
  • Published
  • 1.17 MB
  • 9 dependencies
  • Apache-2.0 license

Install

npm i firebase-admin
yarn add firebase-admin
pnpm add firebase-admin

Overview

Firebase admin SDK for Node.js

Index

Variables

Functions

Interfaces

Namespaces

Variables

variable apps

const apps: app.App[];

    variable SDK_VERSION

    const SDK_VERSION: string;

      Functions

      function app

      app: (name?: string) => app.App;

        function appCheck

        appCheck: (app?: App) => appCheck.AppCheck;
        • Gets the firebase-admin.app-check#AppCheck service for the default app or a given app.

          admin.appCheck() can be called with no arguments to access the default app's AppCheck service or as admin.appCheck(app) to access the AppCheck service associated with a specific app.

          Parameter app

          Optional app for which to return the AppCheck service. If not provided, the default AppCheck service is returned.

          Returns

          The default AppCheck service if no app is provided, or the AppCheck service associated with the provided app.

          Example 1

          // Get the `AppCheck` service for the default app
          var defaultAppCheck = admin.appCheck();

          Example 2

          // Get the `AppCheck` service for a given app
          var otherAppCheck = admin.appCheck(otherApp);

        function auth

        auth: (app?: App) => auth.Auth;
        • Gets the firebase-admin.auth#Auth service for the default app or a given app.

          admin.auth() can be called with no arguments to access the default app's firebase-admin.auth#Auth service or as admin.auth(app) to access the firebase-admin.auth#Auth service associated with a specific app.

          Example 1

          // Get the Auth service for the default app
          var defaultAuth = admin.auth();

          Example 2

          // Get the Auth service for a given app
          var otherAuth = admin.auth(otherApp);

        function database

        database: typeof database;
        • Gets the firebase-admin.database#Database service for the default app or a given app.

          admin.database() can be called with no arguments to access the default app's Database service or as admin.database(app) to access the Database service associated with a specific app.

          admin.database is also a namespace that can be used to access global constants and methods associated with the Database service.

          Parameter App

          whose Database service to return. If not provided, the default Database service will be returned.

          Returns

          The default Database service if no app is provided or the Database service associated with the provided app.

          Example 1

          // Get the Database service for the default app
          var defaultDatabase = admin.database();

          Example 2

          // Get the Database service for a specific app
          var otherDatabase = admin.database(app);

        function firestore

        firestore: typeof firestore;

          function initializeApp

          initializeApp: (options?: AppOptions, name?: string) => app.App;

            function installations

            installations: (app?: App) => installations.Installations;
            • Gets the firebase-admin.installations#Installations service for the default app or a given app.

              admin.installations() can be called with no arguments to access the default app's firebase-admin.installations#Installations service or as admin.installations(app) to access the firebase-admin.installations#Installations service associated with a specific app.

              Parameter app

              Optional app whose Installations service to return. If not provided, the default Installations service is returned.

              Returns

              The default Installations service if no app is provided or the Installations service associated with the provided app.

              Example 1

              // Get the Installations service for the default app
              var defaultInstallations = admin.installations();

              Example 2

              // Get the Installations service for a given app
              var otherInstallations = admin.installations(otherApp);

            function instanceId

            instanceId: (app?: App) => instanceId.InstanceId;
            • Gets the firebase-admin.instance-id#InstanceId service for the default app or a given app.

              admin.instanceId() can be called with no arguments to access the default app's InstanceId service or as admin.instanceId(app) to access the InstanceId service associated with a specific app.

              Parameter app

              Optional app whose InstanceId service to return. If not provided, the default InstanceId service will be returned.

              Returns

              The default InstanceId service if no app is provided or the InstanceId service associated with the provided app.

              Example 1

              // Get the Instance ID service for the default app
              var defaultInstanceId = admin.instanceId();

              Example 2

              // Get the Instance ID service for a given app
              var otherInstanceId = admin.instanceId(otherApp);

            function machineLearning

            machineLearning: (app?: App) => machineLearning.MachineLearning;
            • Gets the firebase-admin.machine-learning#MachineLearning service for the default app or a given app.

              admin.machineLearning() can be called with no arguments to access the default app's MachineLearning service or as admin.machineLearning(app) to access the MachineLearning service associated with a specific app.

              Parameter app

              Optional app whose MachineLearning service to return. If not provided, the default MachineLearning service will be returned.

              Returns

              The default MachineLearning service if no app is provided or the MachineLearning service associated with the provided app.

              Example 1

              // Get the MachineLearning service for the default app
              var defaultMachineLearning = admin.machineLearning();

              Example 2

              // Get the MachineLearning service for a given app
              var otherMachineLearning = admin.machineLearning(otherApp);

            function messaging

            messaging: (app?: App) => messaging.Messaging;
            • Gets the firebase-admin.messaging#Messaging service for the default app or a given app.

              admin.messaging() can be called with no arguments to access the default app's Messaging service or as admin.messaging(app) to access the Messaging service associated with a specific app.

              Parameter app

              Optional app whose Messaging service to return. If not provided, the default Messaging service will be returned.

              Returns

              The default Messaging service if no app is provided or the Messaging service associated with the provided app.

              Example 1

              // Get the Messaging service for the default app
              var defaultMessaging = admin.messaging();

              Example 2

              // Get the Messaging service for a given app
              var otherMessaging = admin.messaging(otherApp);

            function projectManagement

            projectManagement: (app?: App) => projectManagement.ProjectManagement;
            • Gets the firebase-admin.project-management#ProjectManagement service for the default app or a given app.

              admin.projectManagement() can be called with no arguments to access the default app's ProjectManagement service, or as admin.projectManagement(app) to access the ProjectManagement service associated with a specific app.

              Parameter app

              Optional app whose ProjectManagement service to return. If not provided, the default ProjectManagement service will be returned. *

              Returns

              The default ProjectManagement service if no app is provided or the ProjectManagement service associated with the provided app.

              Example 1

              // Get the ProjectManagement service for the default app
              var defaultProjectManagement = admin.projectManagement();

              Example 2

              // Get the ProjectManagement service for a given app
              var otherProjectManagement = admin.projectManagement(otherApp);

            function remoteConfig

            remoteConfig: (app?: App) => remoteConfig.RemoteConfig;
            • Gets the firebase-admin.remote-config#RemoteConfig service for the default app or a given app.

              admin.remoteConfig() can be called with no arguments to access the default app's RemoteConfig service or as admin.remoteConfig(app) to access the RemoteConfig service associated with a specific app.

              Parameter app

              Optional app for which to return the RemoteConfig service. If not provided, the default RemoteConfig service is returned.

              Returns

              The default RemoteConfig service if no app is provided, or the RemoteConfig service associated with the provided app.

              Example 1

              // Get the `RemoteConfig` service for the default app
              var defaultRemoteConfig = admin.remoteConfig();

              Example 2

              // Get the `RemoteConfig` service for a given app
              var otherRemoteConfig = admin.remoteConfig(otherApp);

            function securityRules

            securityRules: (app?: App) => securityRules.SecurityRules;
            • Gets the firebase-admin.security-rules#SecurityRules service for the default app or a given app.

              admin.securityRules() can be called with no arguments to access the default app's firebase-admin.security-rules#SecurityRules service, or as admin.securityRules(app) to access the firebase-admin.security-rules#SecurityRules service associated with a specific app.

              Parameter app

              Optional app to return the SecurityRules service for. If not provided, the default SecurityRules service is returned.

              Returns

              The default SecurityRules service if no app is provided, or the SecurityRules service associated with the provided app.

              Example 1

              // Get the SecurityRules service for the default app
              var defaultSecurityRules = admin.securityRules();

              Example 2

              // Get the SecurityRules service for a given app
              var otherSecurityRules = admin.securityRules(otherApp);

            function storage

            storage: (app?: App) => storage.Storage;
            • Gets the firebase-admin.storage#Storage service for the default app or a given app.

              admin.storage() can be called with no arguments to access the default app's Storage service or as admin.storage(app) to access the Storage service associated with a specific app.

              Example 1

              // Get the Storage service for the default app
              var defaultStorage = admin.storage();

              Example 2

              // Get the Storage service for a given app
              var otherStorage = admin.storage(otherApp);

            Interfaces

            interface AppOptions

            interface AppOptions {}

            property credential

            credential?: Credential;

            property databaseAuthVariableOverride

            databaseAuthVariableOverride?: object | null;
            • The object to use as the auth variable in your Realtime Database Rules when the Admin SDK reads from or writes to the Realtime Database. This allows you to downscope the Admin SDK from its default full read and write privileges.

              You can pass null to act as an unauthenticated client.

              See Authenticate with limited privileges for detailed documentation and code samples.

            property databaseURL

            databaseURL?: string;
            • The URL of the Realtime Database from which to read and write data.

            property httpAgent

            httpAgent?: Agent;
            • An HTTP Agent to be used when making outgoing HTTP calls. This Agent instance is used by all services that make REST calls (e.g. auth, messaging, projectManagement).

              Realtime Database and Firestore use other means of communicating with the backend servers, so they do not use this HTTP Agent. Credential instances also do not use this HTTP Agent, but instead support specifying an HTTP Agent in the corresponding factory methods.

            property projectId

            projectId?: string;
            • The ID of the Google Cloud project associated with the App.

            property serviceAccountId

            serviceAccountId?: string;
            • The ID of the service account to be used for signing custom tokens. This can be found in the client_email field of a service account JSON file.

            property storageBucket

            storageBucket?: string;
            • The name of the Google Cloud Storage bucket used for storing application data. Use only the bucket name without any prefixes or additions (do *not* prefix the name with "gs://").

            interface FirebaseArrayIndexError

            interface FirebaseArrayIndexError {}
            • Composite type which includes both a FirebaseError object and an index which can be used to get the errored item.

              Example 1

              var registrationTokens = [token1, token2, token3];
              admin.messaging().subscribeToTopic(registrationTokens, 'topic-name')
              .then(function(response) {
              if (response.failureCount > 0) {
              console.log("Following devices unsucessfully subscribed to topic:");
              response.errors.forEach(function(error) {
              var invalidToken = registrationTokens[error.index];
              console.log(invalidToken, error.error);
              });
              } else {
              console.log("All devices successfully subscribed to topic:", response);
              }
              })
              .catch(function(error) {
              console.log("Error subscribing to topic:", error);
              });

            property error

            error: FirebaseError;
            • The error object.

            property index

            index: number;
            • The index of the errored item within the original array passed as part of the called API method.

            interface FirebaseError

            interface FirebaseError {}
            • FirebaseError is a subclass of the standard JavaScript Error object. In addition to a message string and stack trace, it contains a string code.

            property code

            code: string;
            • Error codes are strings using the following format: "service/string-code". Some examples include "auth/invalid-uid" and "messaging/invalid-recipient".

              While the message for a given error can change, the code will remain the same between backward-compatible versions of the Firebase SDK.

            property message

            message: string;
            • An explanatory message for the error that just occurred.

              This message is designed to be helpful to you, the developer. Because it generally does not convey meaningful information to end users, this message should not be displayed in your application.

            property stack

            stack?: string;
            • A string value containing the execution backtrace when the error originally occurred.

              This information can be useful for troubleshooting the cause of the error with Firebase Support.

            method toJSON

            toJSON: () => object;
            • Returns a JSON-serializable object representation of this error.

              Returns

              A JSON-serializable representation of this object.

            interface GoogleOAuthAccessToken

            interface GoogleOAuthAccessToken {}
            • Interface for Google OAuth 2.0 access tokens.

            property access_token

            access_token: string;

              property expires_in

              expires_in: number;

                interface ServiceAccount

                interface ServiceAccount {}

                  property clientEmail

                  clientEmail?: string;

                    property privateKey

                    privateKey?: string;

                      property projectId

                      projectId?: string;

                        Namespaces

                        namespace app

                        namespace app {}

                          interface App

                          interface App extends AppCore {}
                          • A Firebase app holds the initialization information for a collection of services.

                            Do not call this constructor directly. Instead, use firebase-admin.app#initializeApp to create an app.

                          method appCheck

                          appCheck: () => appCheck.AppCheck;

                            method auth

                            auth: () => auth.Auth;

                              method database

                              database: (url?: string) => database.Database;

                                method delete

                                delete: () => Promise<void>;
                                • Renders this local FirebaseApp unusable and frees the resources of all associated services (though it does *not* clean up any backend resources). When running the SDK locally, this method must be called to ensure graceful termination of the process.

                                  Example 1

                                  app.delete()
                                  .then(function() {
                                  console.log("App deleted successfully");
                                  })
                                  .catch(function(error) {
                                  console.log("Error deleting app:", error);
                                  });

                                method firestore

                                firestore: () => any;

                                  method installations

                                  installations: () => installations.Installations;

                                    method instanceId

                                    instanceId: () => instanceId.InstanceId;

                                    method machineLearning

                                    machineLearning: () => machineLearning.MachineLearning;

                                      method messaging

                                      messaging: () => messaging.Messaging;

                                        method projectManagement

                                        projectManagement: () => projectManagement.ProjectManagement;

                                          method remoteConfig

                                          remoteConfig: () => remoteConfig.RemoteConfig;

                                            method securityRules

                                            securityRules: () => securityRules.SecurityRules;

                                              method storage

                                              storage: () => storage.Storage;

                                                namespace appCheck

                                                namespace appCheck {}

                                                  type AppCheck

                                                  type AppCheck = TAppCheck;

                                                  type AppCheckToken

                                                  type AppCheckToken = TAppCheckToken;

                                                  type AppCheckTokenOptions

                                                  type AppCheckTokenOptions = TAppCheckTokenOptions;

                                                    type DecodedAppCheckToken

                                                    type DecodedAppCheckToken = TDecodedAppCheckToken;

                                                    type VerifyAppCheckTokenResponse

                                                    type VerifyAppCheckTokenResponse = TVerifyAppCheckTokenResponse;

                                                    namespace auth

                                                    namespace auth {}

                                                      type ActionCodeSettings

                                                      type ActionCodeSettings = TActionCodeSettings;

                                                      type Auth

                                                      type Auth = TAuth;

                                                      type AuthFactorType

                                                      type AuthFactorType = TAuthFactorType;

                                                      type AuthProviderConfig

                                                      type AuthProviderConfig = TAuthProviderConfig;

                                                      type AuthProviderConfigFilter

                                                      type AuthProviderConfigFilter = TAuthProviderConfigFilter;

                                                      type BaseAuth

                                                      type BaseAuth = TBaseAuth;

                                                      type CreateMultiFactorInfoRequest

                                                      type CreateMultiFactorInfoRequest = TCreateMultiFactorInfoRequest;

                                                      type CreatePhoneMultiFactorInfoRequest

                                                      type CreatePhoneMultiFactorInfoRequest = TCreatePhoneMultiFactorInfoRequest;

                                                      type CreateRequest

                                                      type CreateRequest = TCreateRequest;

                                                      type CreateTenantRequest

                                                      type CreateTenantRequest = TCreateTenantRequest;

                                                      type DecodedIdToken

                                                      type DecodedIdToken = TDecodedIdToken;

                                                      type DeleteUsersResult

                                                      type DeleteUsersResult = TDeleteUsersResult;

                                                      type EmailIdentifier

                                                      type EmailIdentifier = TEmailIdentifier;

                                                      type EmailSignInProviderConfig

                                                      type EmailSignInProviderConfig = TEmailSignInProviderConfig;

                                                      type GetUsersResult

                                                      type GetUsersResult = TGetUsersResult;

                                                      type HashAlgorithmType

                                                      type HashAlgorithmType = THashAlgorithmType;

                                                      type ListProviderConfigResults

                                                      type ListProviderConfigResults = TListProviderConfigResults;

                                                      type ListTenantsResult

                                                      type ListTenantsResult = TListTenantsResult;

                                                      type ListUsersResult

                                                      type ListUsersResult = TListUsersResult;

                                                      type MultiFactorConfig

                                                      type MultiFactorConfig = TMultiFactorConfig;

                                                      type MultiFactorConfigState

                                                      type MultiFactorConfigState = TMultiFactorConfigState;

                                                      type MultiFactorCreateSettings

                                                      type MultiFactorCreateSettings = TMultiFactorCreateSettings;

                                                      type MultiFactorInfo

                                                      type MultiFactorInfo = TMultiFactorInfo;

                                                      type MultiFactorSettings

                                                      type MultiFactorSettings = TMultiFactorSettings;

                                                      type MultiFactorUpdateSettings

                                                      type MultiFactorUpdateSettings = TMultiFactorUpdateSettings;

                                                      type OIDCAuthProviderConfig

                                                      type OIDCAuthProviderConfig = TOIDCAuthProviderConfig;

                                                      type OIDCUpdateAuthProviderRequest

                                                      type OIDCUpdateAuthProviderRequest = TOIDCUpdateAuthProviderRequest;

                                                      type PhoneIdentifier

                                                      type PhoneIdentifier = TPhoneIdentifier;

                                                      type PhoneMultiFactorInfo

                                                      type PhoneMultiFactorInfo = TPhoneMultiFactorInfo;

                                                      type ProviderIdentifier

                                                      type ProviderIdentifier = TProviderIdentifier;

                                                      type SAMLAuthProviderConfig

                                                      type SAMLAuthProviderConfig = TSAMLAuthProviderConfig;

                                                      type SAMLUpdateAuthProviderRequest

                                                      type SAMLUpdateAuthProviderRequest = TSAMLUpdateAuthProviderRequest;

                                                      type SessionCookieOptions

                                                      type SessionCookieOptions = TSessionCookieOptions;

                                                      type Tenant

                                                      type Tenant = TTenant;

                                                      type TenantAwareAuth

                                                      type TenantAwareAuth = TTenantAwareAuth;

                                                      type TenantManager

                                                      type TenantManager = TTenantManager;

                                                      type UidIdentifier

                                                      type UidIdentifier = TUidIdentifier;

                                                      type UpdateAuthProviderRequest

                                                      type UpdateAuthProviderRequest = TUpdateAuthProviderRequest;

                                                      type UpdateMultiFactorInfoRequest

                                                      type UpdateMultiFactorInfoRequest = TUpdateMultiFactorInfoRequest;

                                                      type UpdatePhoneMultiFactorInfoRequest

                                                      type UpdatePhoneMultiFactorInfoRequest = TUpdatePhoneMultiFactorInfoRequest;

                                                      type UpdateRequest

                                                      type UpdateRequest = TUpdateRequest;

                                                      type UpdateTenantRequest

                                                      type UpdateTenantRequest = TUpdateTenantRequest;

                                                      type UserIdentifier

                                                      type UserIdentifier = TUserIdentifier;

                                                      type UserImportOptions

                                                      type UserImportOptions = TUserImportOptions;

                                                      type UserImportRecord

                                                      type UserImportRecord = TUserImportRecord;

                                                      type UserImportResult

                                                      type UserImportResult = TUserImportResult;

                                                      type UserInfo

                                                      type UserInfo = TUserInfo;

                                                      type UserMetadata

                                                      type UserMetadata = TUserMetadata;

                                                      type UserMetadataRequest

                                                      type UserMetadataRequest = TUserMetadataRequest;

                                                      type UserProviderRequest

                                                      type UserProviderRequest = TUserProviderRequest;

                                                      type UserRecord

                                                      type UserRecord = TUserRecord;

                                                      namespace credential

                                                      namespace credential {}

                                                        variable applicationDefault

                                                        const applicationDefault: (httpAgent?: any) => TCredential;
                                                        • Returns a credential created from the Google Application Default Credentials that grants admin access to Firebase services. This credential can be used in the call to firebase-admin.app#initializeApp.

                                                          Google Application Default Credentials are available on any Google infrastructure, such as Google App Engine and Google Compute Engine.

                                                          See Initialize the SDK for more details.

                                                          Parameter httpAgent

                                                          Optional HTTP Agent to be used when retrieving access tokens from Google token servers.

                                                          Returns

                                                          A credential authenticated via Google Application Default Credentials that can be used to initialize an app.

                                                          Example 1

                                                          admin.initializeApp({
                                                          credential: admin.credential.applicationDefault(),
                                                          databaseURL: "https://<DATABASE_NAME>.firebaseio.com"
                                                          });

                                                        variable cert

                                                        const cert: (
                                                        serviceAccountPathOrObject: string | ServiceAccount,
                                                        httpAgent?: any
                                                        ) => TCredential;
                                                        • Returns a credential created from the provided service account that grants admin access to Firebase services. This credential can be used in the call to firebase-admin.app#initializeApp.

                                                          See Initialize the SDK for more details.

                                                          Parameter serviceAccountPathOrObject

                                                          The path to a service account key JSON file or an object representing a service account key.

                                                          Parameter httpAgent

                                                          Optional HTTP Agent to be used when retrieving access tokens from Google token servers.

                                                          Returns

                                                          A credential authenticated via the provided service account that can be used to initialize an app.

                                                          Example 1

                                                          // Providing a path to a service account key JSON file
                                                          var serviceAccount = require("path/to/serviceAccountKey.json");
                                                          admin.initializeApp({
                                                          credential: admin.credential.cert(serviceAccount),
                                                          databaseURL: "https://<DATABASE_NAME>.firebaseio.com"
                                                          });

                                                          Example 2

                                                          // Providing a service account object inline
                                                          admin.initializeApp({
                                                          credential: admin.credential.cert({
                                                          projectId: "<PROJECT_ID>",
                                                          clientEmail: "foo@<PROJECT_ID>.iam.gserviceaccount.com",
                                                          privateKey: "-----BEGIN PRIVATE KEY-----<KEY>-----END PRIVATE KEY-----\n"
                                                          }),
                                                          databaseURL: "https://<DATABASE_NAME>.firebaseio.com"
                                                          });

                                                        variable refreshToken

                                                        const refreshToken: (
                                                        refreshTokenPathOrObject: string | object,
                                                        httpAgent?: any
                                                        ) => TCredential;
                                                        • Returns a credential created from the provided refresh token that grants admin access to Firebase services. This credential can be used in the call to firebase-admin.app#initializeApp.

                                                          See Initialize the SDK for more details.

                                                          Parameter refreshTokenPathOrObject

                                                          The path to a Google OAuth2 refresh token JSON file or an object representing a Google OAuth2 refresh token.

                                                          Parameter httpAgent

                                                          Optional HTTP Agent to be used when retrieving access tokens from Google token servers.

                                                          Returns

                                                          A credential authenticated via the provided service account that can be used to initialize an app.

                                                          Example 1

                                                          // Providing a path to a refresh token JSON file
                                                          var refreshToken = require("path/to/refreshToken.json");
                                                          admin.initializeApp({
                                                          credential: admin.credential.refreshToken(refreshToken),
                                                          databaseURL: "https://<DATABASE_NAME>.firebaseio.com"
                                                          });

                                                        type Credential

                                                        type Credential = TCredential;
                                                        • Interface that provides Google OAuth2 access tokens used to authenticate with Firebase services.

                                                          In most cases, you will not need to implement this yourself and can instead use the default implementations provided by the admin.credential namespace.

                                                        namespace database

                                                        namespace database {}

                                                          variable enableLogging

                                                          const enableLogging: any;

                                                          variable ServerValue

                                                          const ServerValue: any;
                                                          • ServerValue constant from the @firebase/database package.

                                                          type Database

                                                          type Database = TDatabase;

                                                          type DataSnapshot

                                                          type DataSnapshot = rtdb.DataSnapshot;
                                                          • Type alias to DataSnapshot type from the @firebase/database package.

                                                          type EventType

                                                          type EventType = rtdb.EventType;
                                                          • Type alias to the EventType type from the @firebase/database package.

                                                          type OnDisconnect

                                                          type OnDisconnect = rtdb.OnDisconnect;
                                                          • Type alias to OnDisconnect type from the @firebase/database package.

                                                          type Query

                                                          type Query = rtdb.Query;
                                                          • Type alias to Query type from the @firebase/database package.

                                                          type Reference

                                                          type Reference = rtdb.Reference;
                                                          • Type alias to Reference type from the @firebase/database package.

                                                          type ThenableReference

                                                          type ThenableReference = rtdb.ThenableReference;

                                                          namespace firestore

                                                          namespace firestore {}

                                                            namespace installations

                                                            namespace installations {}

                                                              type Installations

                                                              type Installations = TInstallations;

                                                              namespace instanceId

                                                              namespace instanceId {}

                                                                type InstanceId

                                                                type InstanceId = TInstanceId;

                                                                namespace machineLearning

                                                                namespace machineLearning {}

                                                                  type AutoMLTfliteModelOptions

                                                                  type AutoMLTfliteModelOptions = TAutoMLTfliteModelOptions;

                                                                  type GcsTfliteModelOptions

                                                                  type GcsTfliteModelOptions = TGcsTfliteModelOptions;

                                                                  type ListModelsOptions

                                                                  type ListModelsOptions = TListModelsOptions;

                                                                  type ListModelsResult

                                                                  type ListModelsResult = TListModelsResult;

                                                                  type MachineLearning

                                                                  type MachineLearning = TMachineLearning;

                                                                  type Model

                                                                  type Model = TModel;

                                                                  type ModelOptions

                                                                  type ModelOptions = TModelOptions;

                                                                  type ModelOptionsBase

                                                                  type ModelOptionsBase = TModelOptionsBase;

                                                                  type TFLiteModel

                                                                  type TFLiteModel = TTFLiteModel;

                                                                  namespace messaging

                                                                  namespace messaging {}

                                                                    type AndroidConfig

                                                                    type AndroidConfig = TAndroidConfig;

                                                                    type AndroidFcmOptions

                                                                    type AndroidFcmOptions = TAndroidFcmOptions;

                                                                    type AndroidNotification

                                                                    type AndroidNotification = TAndroidNotification;

                                                                    type ApnsConfig

                                                                    type ApnsConfig = TApnsConfig;

                                                                    type ApnsFcmOptions

                                                                    type ApnsFcmOptions = TApnsFcmOptions;

                                                                    type ApnsPayload

                                                                    type ApnsPayload = TApnsPayload;

                                                                    type Aps

                                                                    type Aps = TAps;

                                                                    type ApsAlert

                                                                    type ApsAlert = TApsAlert;

                                                                    type BatchResponse

                                                                    type BatchResponse = TBatchResponse;

                                                                    type ConditionMessage

                                                                    type ConditionMessage = TConditionMessage;

                                                                    type CriticalSound

                                                                    type CriticalSound = TCriticalSound;

                                                                    type DataMessagePayload

                                                                    type DataMessagePayload = TDataMessagePayload;

                                                                    type FcmOptions

                                                                    type FcmOptions = TFcmOptions;

                                                                    type LightSettings

                                                                    type LightSettings = TLightSettings;

                                                                    type Message

                                                                    type Message = TMessage;

                                                                    type Messaging

                                                                    type Messaging = TMessaging;

                                                                    type MessagingConditionResponse

                                                                    type MessagingConditionResponse = TMessagingConditionResponse;

                                                                    type MessagingDeviceGroupResponse

                                                                    type MessagingDeviceGroupResponse = TMessagingDeviceGroupResponse;

                                                                    type MessagingDeviceResult

                                                                    type MessagingDeviceResult = TMessagingDeviceResult;

                                                                    type MessagingDevicesResponse

                                                                    type MessagingDevicesResponse = TMessagingDevicesResponse;

                                                                    type MessagingOptions

                                                                    type MessagingOptions = TMessagingOptions;

                                                                    type MessagingPayload

                                                                    type MessagingPayload = TMessagingPayload;

                                                                    type MessagingTopicManagementResponse

                                                                    type MessagingTopicManagementResponse = TMessagingTopicManagementResponse;

                                                                    type MessagingTopicResponse

                                                                    type MessagingTopicResponse = TMessagingTopicResponse;

                                                                    type MulticastMessage

                                                                    type MulticastMessage = TMulticastMessage;

                                                                    type Notification

                                                                    type Notification = TNotification;

                                                                    type NotificationMessagePayload

                                                                    type NotificationMessagePayload = TNotificationMessagePayload;

                                                                    type SendResponse

                                                                    type SendResponse = TSendResponse;

                                                                    type TokenMessage

                                                                    type TokenMessage = TTokenMessage;

                                                                    type TopicMessage

                                                                    type TopicMessage = TTopicMessage;

                                                                    type WebpushConfig

                                                                    type WebpushConfig = TWebpushConfig;

                                                                    type WebpushFcmOptions

                                                                    type WebpushFcmOptions = TWebpushFcmOptions;

                                                                    type WebpushNotification

                                                                    type WebpushNotification = TWebpushNotification;

                                                                    namespace projectManagement

                                                                    namespace projectManagement {}

                                                                      type AndroidApp

                                                                      type AndroidApp = TAndroidApp;

                                                                      type AndroidAppMetadata

                                                                      type AndroidAppMetadata = TAndroidAppMetadata;

                                                                      type AppMetadata

                                                                      type AppMetadata = TAppMetadata;

                                                                      type AppPlatform

                                                                      type AppPlatform = TAppPlatform;

                                                                      type IosApp

                                                                      type IosApp = TIosApp;

                                                                      type IosAppMetadata

                                                                      type IosAppMetadata = TIosAppMetadata;

                                                                      type ProjectManagement

                                                                      type ProjectManagement = TProjectManagement;

                                                                      type ShaCertificate

                                                                      type ShaCertificate = TShaCertificate;

                                                                      namespace remoteConfig

                                                                      namespace remoteConfig {}

                                                                        type ExplicitParameterValue

                                                                        type ExplicitParameterValue = TExplicitParameterValue;

                                                                        type InAppDefaultValue

                                                                        type InAppDefaultValue = TInAppDefaultValue;

                                                                        type ListVersionsOptions

                                                                        type ListVersionsOptions = TListVersionsOptions;

                                                                        type ListVersionsResult

                                                                        type ListVersionsResult = TListVersionsResult;

                                                                        type ParameterValueType

                                                                        type ParameterValueType = TParameterValueType;

                                                                        type RemoteConfig

                                                                        type RemoteConfig = TRemoteConfig;

                                                                        type RemoteConfigCondition

                                                                        type RemoteConfigCondition = TRemoteConfigCondition;

                                                                        type RemoteConfigParameter

                                                                        type RemoteConfigParameter = TRemoteConfigParameter;

                                                                        type RemoteConfigParameterGroup

                                                                        type RemoteConfigParameterGroup = TRemoteConfigParameterGroup;

                                                                        type RemoteConfigParameterValue

                                                                        type RemoteConfigParameterValue = TRemoteConfigParameterValue;

                                                                        type RemoteConfigTemplate

                                                                        type RemoteConfigTemplate = TRemoteConfigTemplate;

                                                                        type RemoteConfigUser

                                                                        type RemoteConfigUser = TRemoteConfigUser;

                                                                        type TagColor

                                                                        type TagColor = TTagColor;

                                                                        type Version

                                                                        type Version = TVersion;

                                                                        namespace securityRules

                                                                        namespace securityRules {}

                                                                          type Ruleset

                                                                          type Ruleset = TRuleset;

                                                                          type RulesetMetadata

                                                                          type RulesetMetadata = TRulesetMetadata;

                                                                          type RulesetMetadataList

                                                                          type RulesetMetadataList = TRulesetMetadataList;

                                                                          type RulesFile

                                                                          type RulesFile = TRulesFile;

                                                                          type SecurityRules

                                                                          type SecurityRules = TSecurityRules;

                                                                          namespace storage

                                                                          namespace storage {}

                                                                            type Storage

                                                                            type Storage = TStorage;

                                                                            Package Files (17)

                                                                            Dependencies (9)

                                                                            Dev Dependencies (48)

                                                                            Peer Dependencies (0)

                                                                            No peer dependencies.

                                                                            Badge

                                                                            To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/firebase-admin.

                                                                            • Markdown
                                                                              [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/firebase-admin)
                                                                            • HTML
                                                                              <a href="https://www.jsdocs.io/package/firebase-admin"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>