firebase

  • Version 10.14.1
  • Published
  • 24.9 MB
  • 28 dependencies
  • Apache-2.0 license

Install

npm i firebase
yarn add firebase
pnpm add firebase

Overview

Firebase JavaScript library for web and Node.js

Index

Namespaces

Namespaces

namespace firebase

namespace firebase {}
  • firebase is a global namespace from which all Firebase services are accessed.

variable apps

var apps: app.App[];
  • A (read-only) array of all initialized apps.

variable SDK_VERSION

var SDK_VERSION: string;
  • The current SDK version.

function analytics

analytics: typeof analytics;
  • Gets the service.

    firebase.analytics() can be called with no arguments to access the default app's service.

    The Analytics SDK does not work in a Node.js environment.

    Parameter app

    The app to create an analytics service for. If not passed, uses the default app.

    Example 1

    // Get the Analytics service for the default app
    const defaultAnalytics = firebase.analytics();

function app

app: (name?: string) => app.App;
  • Retrieves a Firebase instance.

    When called with no arguments, the default app is returned. When an app name is provided, the app corresponding to that name is returned.

    An exception is thrown if the app being retrieved has not yet been initialized.

    Parameter name

    Optional name of the app to return. If no name is provided, the default is "[DEFAULT]".

    The app corresponding to the provided app name. If no app name is provided, the default app is returned.

    Example 1

    // Return the default app
    var app = firebase.app();

    Example 2

    // Return a named app
    var otherApp = firebase.app("otherApp");

function appCheck

appCheck: typeof appCheck;

    function auth

    auth: typeof auth;
    • Gets the service for the default app or a given app.

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

      Parameter app

      Example 1

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

      Example 2

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

    function database

    database: typeof database;
    • Gets the service for the default app or a given app.

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

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

      Parameter app

      Optional app whose Database service to return. If not provided, the default Database service will be returned. 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 = firebase.database();

      Example 2

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

    function firestore

    firestore: typeof firestore;

      function functions

      functions: typeof functions;

        function initializeApp

        initializeApp: (options: Object, name?: string) => app.App;
        • Creates and initializes a Firebase instance.

          See and for detailed documentation.

          Parameter options

          Options to configure the app's services.

          Parameter name

          Optional name of the app to initialize. If no name is provided, the default is "[DEFAULT]".

          {!firebase.app.App} The initialized app.

          Example 1

          // Initialize default app
          // Retrieve your own options values by adding a web app on
          // https://console.firebase.google.com
          firebase.initializeApp({
          apiKey: "AIza....", // Auth / General Use
          appId: "1:27992087142:web:ce....", // General Use
          projectId: "my-firebase-project", // General Use
          authDomain: "YOUR_APP.firebaseapp.com", // Auth with popup/redirect
          databaseURL: "https://YOUR_APP.firebaseio.com", // Realtime Database
          storageBucket: "YOUR_APP.appspot.com", // Storage
          messagingSenderId: "123456789", // Cloud Messaging
          measurementId: "G-12345" // Analytics
          });

          Example 2

          // Initialize another app
          var otherApp = firebase.initializeApp({
          apiKey: "AIza....",
          appId: "1:27992087142:web:ce....",
          projectId: "my-firebase-project",
          databaseURL: "https://<OTHER_DATABASE_NAME>.firebaseio.com",
          storageBucket: "<OTHER_STORAGE_BUCKET>.appspot.com"
          }, "nameOfOtherApp");

        function messaging

        messaging: typeof messaging;
        • Gets the service for the default app or a given app.

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

          Calling firebase.messaging() in a service worker results in Firebase generating notifications if the push message payload has a notification parameter.

          The Messaging SDK does not work in a Node.js environment.

          Parameter app

          The app to create a Messaging service for. If not passed, uses the default app.

          Example 1

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

          Example 2

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

        function onLog

        onLog: (
        logCallback: (callbackParams: {
        level: LogLevel;
        message: string;
        args: any[];
        type: string;
        }) => void,
        options?: { level: LogLevel }
        ) => void;
        • Sets log handler for all Firebase packages.

          Parameter logCallback

          An optional custom log handler that executes user code whenever the Firebase SDK makes a logging call.

        function performance

        performance: (app?: app.App) => performance.Performance;
        • Gets the service.

          firebase.performance() can be called with no arguments to access the default app's service. The service does not work with any other app.

          The Performance SDK does not work in a Node.js environment.

          Parameter app

          The app to create a performance service for. Performance Monitoring only works with the default app. If not passed, uses the default app.

          Example 1

          // Get the Performance service for the default app
          const defaultPerformance = firebase.performance();

        function registerVersion

        registerVersion: (library: string, version: string, variant?: string) => void;
        • Registers a library's name and version for platform logging purposes.

          Parameter library

          Name of 1p or 3p library (e.g. firestore, angularfire)

          Parameter version

          Current version of that library.

          Parameter variant

          Bundle variant, e.g., node, rn, etc.

        function remoteConfig

        remoteConfig: typeof remoteConfig;
        • Gets the instance.

          The Remote Config SDK does not work in a Node.js environment.

          Parameter app

          The app to create a Remote Config service for. If not passed, uses the default app.

          Example 1

          // Get the RemoteConfig instance for the default app
          const defaultRemoteConfig = firebase.remoteConfig();

        function setLogLevel

        setLogLevel: (logLevel: LogLevel) => void;
        • Sets log level for all Firebase packages.

          All of the log types above the current log level are captured (i.e. if you set the log level to info, errors are logged, but debug and verbose logs are not).

        function storage

        storage: typeof storage;
        • Gets the service for the default app or a given app.

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

          Parameter app

          The app to create a storage service for. If not passed, uses the default app.

          Example 1

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

          Example 2

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

        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 "app/no-app" and "auth/user-not-found".

          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 name

        name: 'FirebaseError';
        • The name of the class of errors, which is "FirebaseError".

        property stack

        stack?: string;
        • A string value containing the execution backtrace when the error originally occurred. This may not always be available.

          When it is available, this information can be sent to to help explain the cause of an error.

        interface FirebaseIdToken

        interface FirebaseIdToken {}

          property aud

          aud: string;
          • Always set to PROJECT_ID

          property auth_time

          auth_time: number;
          • The time the user authenticated, normally 'iat'

          property email

          email?: string;
          • The user's primary email

          property email_verified

          email_verified?: boolean;
          • The user's email verification status

          property exp

          exp: number;
          • The token expiry time, normally 'iat' + 3600

          property firebase

          firebase: {
          /** The primary sign-in provider */
          sign_in_provider: FirebaseSignInProvider;
          /** A map of providers to the user's list of unique identifiers from each provider */
          identities?: { [provider in FirebaseSignInProvider]?: string[] };
          };
          • Information on all identities linked to this user

          property iat

          iat: number;
          • The token issue time, in seconds since epoch

          property iss

          iss: string;
          • Always set to https://securetoken.google.com/PROJECT_ID

          property name

          name?: string;
          • The user's display name

          property phone_number

          phone_number?: string;
          • The user's primary phone number

          property picture

          picture?: string;
          • The user's profile photo URL

          property provider_id

          provider_id?: 'anonymous';
          • The sign in provider, only set when the provider is 'anonymous'

          property sub

          sub: string;
          • The user's unique ID

          property uid

          uid?: never;

            property user_id

            user_id: string;
            • The user's unique ID. Must be equal to 'sub'

            index signature

            [claim: string]: unknown;
            • Custom claims set by the developer

            interface Observer

            interface Observer<T, E = Error> {}

            property complete

            complete: CompleteFn;

              property error

              error: ErrorFn<E>;

                property next

                next: NextFn<T>;

                  interface User

                  interface User extends firebase.UserInfo {}
                  • A user account.

                  property emailVerified

                  emailVerified: boolean;

                    property isAnonymous

                    isAnonymous: boolean;

                      property metadata

                      metadata: firebase.auth.UserMetadata;

                        property multiFactor

                        multiFactor: firebase.User.MultiFactorUser;
                        • The firebase.User.MultiFactorUser object corresponding to the current user. This is used to access all multi-factor properties and operations related to the current user.

                        property phoneNumber

                        phoneNumber: string | null;
                        • The phone number normalized based on the E.164 standard (e.g. +16505550101) for the current user. This is null if the user has no phone credential linked to the account.

                        property providerData

                        providerData: (firebase.UserInfo | null)[];

                          property refreshToken

                          refreshToken: string;

                            property tenantId

                            tenantId: string | null;
                            • The current user's tenant ID. This is a read-only property, which indicates the tenant ID used to sign in the current user. This is null if the user is signed in from the parent project.

                              Example 1

                              // Set the tenant ID on Auth instance.
                              firebase.auth().tenantId =TENANT_PROJECT_ID;
                              // All future sign-in request now include tenant ID.
                              firebase.auth().signInWithEmailAndPassword(email, password)
                              .then(function(result) {
                              // result.user.tenantId should be ‘TENANT_PROJECT_ID’.
                              }).catch(function(error) {
                              // Handle error.
                              });

                            method delete

                            delete: () => Promise<void>;
                            • Deletes and signs out the user.

                              Important: this is a security-sensitive operation that requires the user to have recently signed in. If this requirement isn't met, ask the user to authenticate again and then call firebase.User.reauthenticateWithCredential.

                              Error Codes auth/requires-recent-login Thrown if the user's last sign-in time does not meet the security threshold. Use firebase.User.reauthenticateWithCredential to resolve. This does not apply if the user is anonymous.

                            method getIdToken

                            getIdToken: (forceRefresh?: boolean) => Promise<string>;
                            • Returns a JSON Web Token (JWT) used to identify the user to a Firebase service.

                              Returns the current token if it has not expired. Otherwise, this will refresh the token and return a new one.

                              Parameter forceRefresh

                              Force refresh regardless of token expiration.

                            method getIdTokenResult

                            getIdTokenResult: (forceRefresh?: boolean) => Promise<auth.IdTokenResult>;

                              method linkAndRetrieveDataWithCredential

                              linkAndRetrieveDataWithCredential: (
                              credential: auth.AuthCredential
                              ) => Promise<auth.UserCredential>;
                              • Links the user account with the given credentials and returns any available additional user information, such as user name.

                                Error Codes auth/provider-already-linked Thrown if the provider has already been linked to the user. This error is thrown even if this is not the same provider's account that is currently linked to the user. auth/invalid-credential Thrown if the provider's credential is not valid. This can happen if it has already expired when calling link, or if it used invalid token(s). See the Firebase documentation for your provider, and make sure you pass in the correct parameters to the credential method. auth/credential-already-in-use Thrown if the account corresponding to the credential already exists among your users, or is already linked to a Firebase User. For example, this error could be thrown if you are upgrading an anonymous user to a Google user by linking a Google credential to it and the Google credential used is already associated with an existing Firebase Google user. The fields error.email, error.phoneNumber, and error.credential (firebase.auth.AuthCredential) may be provided, depending on the type of credential. You can recover from this error by signing in with error.credential directly via firebase.auth.Auth.signInWithCredential. auth/email-already-in-use Thrown if the email corresponding to the credential already exists among your users. When thrown while linking a credential to an existing user, an error.email and error.credential (firebase.auth.AuthCredential) fields are also provided. You have to link the credential to the existing user with that email if you wish to continue signing in with that credential. To do so, call firebase.auth.Auth.fetchSignInMethodsForEmail, sign in to error.email via one of the providers returned and then firebase.User.linkWithCredential the original credential to that newly signed in user. auth/operation-not-allowed Thrown if you have not enabled the provider in the Firebase Console. Go to the Firebase Console for your project, in the Auth section and the Sign in Method tab and configure the provider. auth/invalid-email Thrown if the email used in a firebase.auth.EmailAuthProvider.credential is invalid. auth/wrong-password Thrown if the password used in a firebase.auth.EmailAuthProvider.credential is not correct or when the user associated with the email does not have a password. auth/invalid-verification-code Thrown if the credential is a firebase.auth.PhoneAuthProvider.credential and the verification code of the credential is not valid. auth/invalid-verification-id Thrown if the credential is a firebase.auth.PhoneAuthProvider.credential and the verification ID of the credential is not valid.

                                Parameter credential

                                The auth credential.

                                Deprecated

                                This method is deprecated. Use firebase.User.linkWithCredential instead.

                              method linkWithCredential

                              linkWithCredential: (
                              credential: auth.AuthCredential
                              ) => Promise<auth.UserCredential>;
                              • Links the user account with the given credentials.

                                Error Codes auth/provider-already-linked Thrown if the provider has already been linked to the user. This error is thrown even if this is not the same provider's account that is currently linked to the user. auth/invalid-credential Thrown if the provider's credential is not valid. This can happen if it has already expired when calling link, or if it used invalid token(s). See the Firebase documentation for your provider, and make sure you pass in the correct parameters to the credential method. auth/credential-already-in-use Thrown if the account corresponding to the credential already exists among your users, or is already linked to a Firebase User. For example, this error could be thrown if you are upgrading an anonymous user to a Google user by linking a Google credential to it and the Google credential used is already associated with an existing Firebase Google user. The fields error.email, error.phoneNumber, and error.credential (firebase.auth.AuthCredential) may be provided, depending on the type of credential. You can recover from this error by signing in with error.credential directly via firebase.auth.Auth.signInWithCredential. auth/email-already-in-use Thrown if the email corresponding to the credential already exists among your users. When thrown while linking a credential to an existing user, an error.email and error.credential (firebase.auth.AuthCredential) fields are also provided. You have to link the credential to the existing user with that email if you wish to continue signing in with that credential. To do so, call firebase.auth.Auth.fetchSignInMethodsForEmail, sign in to error.email via one of the providers returned and then firebase.User.linkWithCredential the original credential to that newly signed in user. auth/operation-not-allowed Thrown if you have not enabled the provider in the Firebase Console. Go to the Firebase Console for your project, in the Auth section and the Sign in Method tab and configure the provider. auth/invalid-email Thrown if the email used in a firebase.auth.EmailAuthProvider.credential is invalid. auth/wrong-password Thrown if the password used in a firebase.auth.EmailAuthProvider.credential is not correct or when the user associated with the email does not have a password. auth/invalid-verification-code Thrown if the credential is a firebase.auth.PhoneAuthProvider.credential and the verification code of the credential is not valid. auth/invalid-verification-id Thrown if the credential is a firebase.auth.PhoneAuthProvider.credential and the verification ID of the credential is not valid.

                                Parameter credential

                                The auth credential.

                              method linkWithPhoneNumber

                              linkWithPhoneNumber: (
                              phoneNumber: string,
                              applicationVerifier: auth.ApplicationVerifier
                              ) => Promise<auth.ConfirmationResult>;
                              • Links the user account with the given phone number.

                                Error Codes auth/provider-already-linked Thrown if the provider has already been linked to the user. This error is thrown even if this is not the same provider's account that is currently linked to the user. auth/captcha-check-failed Thrown if the reCAPTCHA response token was invalid, expired, or if this method was called from a non-whitelisted domain. auth/invalid-phone-number Thrown if the phone number has an invalid format. auth/missing-phone-number Thrown if the phone number is missing. auth/quota-exceeded Thrown if the SMS quota for the Firebase project has been exceeded. auth/user-disabled Thrown if the user corresponding to the given phone number has been disabled. auth/credential-already-in-use Thrown if the account corresponding to the phone number already exists among your users, or is already linked to a Firebase User. The fields error.phoneNumber and error.credential (firebase.auth.AuthCredential) are provided in this case. You can recover from this error by signing in with that credential directly via firebase.auth.Auth.signInWithCredential. auth/operation-not-allowed Thrown if you have not enabled the phone authentication provider in the Firebase Console. Go to the Firebase Console for your project, in the Auth section and the Sign in Method tab and configure the provider.

                                Parameter phoneNumber

                                The user's phone number in E.164 format (e.g. +16505550101).

                                Parameter applicationVerifier

                              method linkWithPopup

                              linkWithPopup: (provider: auth.AuthProvider) => Promise<auth.UserCredential>;
                              • Links the authenticated provider to the user account using a pop-up based OAuth flow.

                                If the linking is successful, the returned result will contain the user and the provider's credential.

                                Error Codes auth/auth-domain-config-required Thrown if authDomain configuration is not provided when calling firebase.initializeApp(). Check Firebase Console for instructions on determining and passing that field. auth/cancelled-popup-request Thrown if successive popup operations are triggered. Only one popup request is allowed at one time on a user or an auth instance. All the popups would fail with this error except for the last one. auth/credential-already-in-use Thrown if the account corresponding to the credential already exists among your users, or is already linked to a Firebase User. For example, this error could be thrown if you are upgrading an anonymous user to a Google user by linking a Google credential to it and the Google credential used is already associated with an existing Firebase Google user. An error.email and error.credential (firebase.auth.AuthCredential) fields are also provided. You can recover from this error by signing in with that credential directly via firebase.auth.Auth.signInWithCredential. auth/email-already-in-use Thrown if the email corresponding to the credential already exists among your users. When thrown while linking a credential to an existing user, an error.email and error.credential (firebase.auth.AuthCredential) fields are also provided. You have to link the credential to the existing user with that email if you wish to continue signing in with that credential. To do so, call firebase.auth.Auth.fetchSignInMethodsForEmail, sign in to error.email via one of the providers returned and then firebase.User.linkWithCredential the original credential to that newly signed in user. auth/operation-not-allowed Thrown if you have not enabled the provider in the Firebase Console. Go to the Firebase Console for your project, in the Auth section and the Sign in Method tab and configure the provider. auth/popup-blocked auth/operation-not-supported-in-this-environment Thrown if this operation is not supported in the environment your application is running on. "location.protocol" must be http or https. Thrown if the popup was blocked by the browser, typically when this operation is triggered outside of a click handler. auth/popup-closed-by-user Thrown if the popup window is closed by the user without completing the sign in to the provider. auth/provider-already-linked Thrown if the provider has already been linked to the user. This error is thrown even if this is not the same provider's account that is currently linked to the user. auth/unauthorized-domain Thrown if the app domain is not authorized for OAuth operations for your Firebase project. Edit the list of authorized domains from the Firebase console.

                                This method does not work in a Node.js environment.

                                Parameter provider

                                The provider to authenticate. The provider has to be an OAuth provider. Non-OAuth providers like firebase.auth.EmailAuthProvider will throw an error.

                                Example 1

                                // Creates the provider object.
                                var provider = new firebase.auth.FacebookAuthProvider();
                                // You can add additional scopes to the provider:
                                provider.addScope('email');
                                provider.addScope('user_friends');
                                // Link with popup:
                                user.linkWithPopup(provider).then(function(result) {
                                // The firebase.User instance:
                                var user = result.user;
                                // The Facebook firebase.auth.AuthCredential containing the Facebook
                                // access token:
                                var credential = result.credential;
                                }, function(error) {
                                // An error happened.
                                });

                              method linkWithRedirect

                              linkWithRedirect: (provider: auth.AuthProvider) => Promise<void>;
                              • Links the authenticated provider to the user account using a full-page redirect flow.

                                Error Codes auth/auth-domain-config-required Thrown if authDomain configuration is not provided when calling firebase.initializeApp(). Check Firebase Console for instructions on determining and passing that field. auth/operation-not-supported-in-this-environment Thrown if this operation is not supported in the environment your application is running on. "location.protocol" must be http or https. auth/provider-already-linked Thrown if the provider has already been linked to the user. This error is thrown even if this is not the same provider's account that is currently linked to the user. auth/unauthorized-domain Thrown if the app domain is not authorized for OAuth operations for your Firebase project. Edit the list of authorized domains from the Firebase console.

                                Parameter provider

                                The provider to authenticate. The provider has to be an OAuth provider. Non-OAuth providers like firebase.auth.EmailAuthProvider will throw an error.

                              method reauthenticateAndRetrieveDataWithCredential

                              reauthenticateAndRetrieveDataWithCredential: (
                              credential: auth.AuthCredential
                              ) => Promise<auth.UserCredential>;
                              • Re-authenticates a user using a fresh credential, and returns any available additional user information, such as user name. Use before operations such as firebase.User.updatePassword that require tokens from recent sign-in attempts.

                                Error Codes auth/user-mismatch Thrown if the credential given does not correspond to the user. auth/user-not-found Thrown if the credential given does not correspond to any existing user. auth/invalid-credential Thrown if the provider's credential is not valid. This can happen if it has already expired when calling link, or if it used invalid token(s). See the Firebase documentation for your provider, and make sure you pass in the correct parameters to the credential method. auth/invalid-email Thrown if the email used in a firebase.auth.EmailAuthProvider.credential is invalid. auth/wrong-password Thrown if the password used in a firebase.auth.EmailAuthProvider.credential is not correct or when the user associated with the email does not have a password. auth/invalid-verification-code Thrown if the credential is a firebase.auth.PhoneAuthProvider.credential and the verification code of the credential is not valid. auth/invalid-verification-id Thrown if the credential is a firebase.auth.PhoneAuthProvider.credential and the verification ID of the credential is not valid.

                                Parameter credential

                                Deprecated

                                This method is deprecated. Use firebase.User.reauthenticateWithCredential instead.

                              method reauthenticateWithCredential

                              reauthenticateWithCredential: (
                              credential: auth.AuthCredential
                              ) => Promise<auth.UserCredential>;
                              • Re-authenticates a user using a fresh credential. Use before operations such as firebase.User.updatePassword that require tokens from recent sign-in attempts.

                                Error Codes auth/user-mismatch Thrown if the credential given does not correspond to the user. auth/user-not-found Thrown if the credential given does not correspond to any existing user. auth/invalid-credential Thrown if the provider's credential is not valid. This can happen if it has already expired when calling link, or if it used invalid token(s). See the Firebase documentation for your provider, and make sure you pass in the correct parameters to the credential method. auth/invalid-email Thrown if the email used in a firebase.auth.EmailAuthProvider.credential is invalid. auth/wrong-password Thrown if the password used in a firebase.auth.EmailAuthProvider.credential is not correct or when the user associated with the email does not have a password. auth/invalid-verification-code Thrown if the credential is a firebase.auth.PhoneAuthProvider.credential and the verification code of the credential is not valid. auth/invalid-verification-id Thrown if the credential is a firebase.auth.PhoneAuthProvider.credential and the verification ID of the credential is not valid.

                                Parameter credential

                              method reauthenticateWithPhoneNumber

                              reauthenticateWithPhoneNumber: (
                              phoneNumber: string,
                              applicationVerifier: auth.ApplicationVerifier
                              ) => Promise<auth.ConfirmationResult>;
                              • Re-authenticates a user using a fresh credential. Use before operations such as firebase.User.updatePassword that require tokens from recent sign-in attempts.

                                Error Codes auth/user-mismatch Thrown if the credential given does not correspond to the user. auth/user-not-found Thrown if the credential given does not correspond to any existing user. auth/captcha-check-failed Thrown if the reCAPTCHA response token was invalid, expired, or if this method was called from a non-whitelisted domain. auth/invalid-phone-number Thrown if the phone number has an invalid format. auth/missing-phone-number Thrown if the phone number is missing. auth/quota-exceeded Thrown if the SMS quota for the Firebase project has been exceeded.

                                Parameter phoneNumber

                                The user's phone number in E.164 format (e.g. +16505550101).

                                Parameter applicationVerifier

                              method reauthenticateWithPopup

                              reauthenticateWithPopup: (
                              provider: auth.AuthProvider
                              ) => Promise<auth.UserCredential>;
                              • Reauthenticates the current user with the specified provider using a pop-up based OAuth flow.

                                If the reauthentication is successful, the returned result will contain the user and the provider's credential.

                                Error Codes auth/auth-domain-config-required Thrown if authDomain configuration is not provided when calling firebase.initializeApp(). Check Firebase Console for instructions on determining and passing that field. auth/cancelled-popup-request Thrown if successive popup operations are triggered. Only one popup request is allowed at one time on a user or an auth instance. All the popups would fail with this error except for the last one. auth/user-mismatch Thrown if the credential given does not correspond to the user. auth/operation-not-allowed Thrown if you have not enabled the provider in the Firebase Console. Go to the Firebase Console for your project, in the Auth section and the Sign in Method tab and configure the provider. auth/popup-blocked Thrown if the popup was blocked by the browser, typically when this operation is triggered outside of a click handler. auth/operation-not-supported-in-this-environment Thrown if this operation is not supported in the environment your application is running on. "location.protocol" must be http or https. auth/popup-closed-by-user Thrown if the popup window is closed by the user without completing the sign in to the provider. auth/unauthorized-domain Thrown if the app domain is not authorized for OAuth operations for your Firebase project. Edit the list of authorized domains from the Firebase console.

                                This method does not work in a Node.js environment.

                                Parameter provider

                                The provider to authenticate. The provider has to be an OAuth provider. Non-OAuth providers like firebase.auth.EmailAuthProvider will throw an error.

                                Example 1

                                // Creates the provider object.
                                var provider = new firebase.auth.FacebookAuthProvider();
                                // You can add additional scopes to the provider:
                                provider.addScope('email');
                                provider.addScope('user_friends');
                                // Reauthenticate with popup:
                                user.reauthenticateWithPopup(provider).then(function(result) {
                                // The firebase.User instance:
                                var user = result.user;
                                // The Facebook firebase.auth.AuthCredential containing the Facebook
                                // access token:
                                var credential = result.credential;
                                }, function(error) {
                                // An error happened.
                                });

                              method reauthenticateWithRedirect

                              reauthenticateWithRedirect: (provider: auth.AuthProvider) => Promise<void>;
                              • Reauthenticates the current user with the specified OAuth provider using a full-page redirect flow.

                                Error Codes auth/auth-domain-config-required Thrown if authDomain configuration is not provided when calling firebase.initializeApp(). Check Firebase Console for instructions on determining and passing that field. auth/operation-not-supported-in-this-environment Thrown if this operation is not supported in the environment your application is running on. "location.protocol" must be http or https. auth/user-mismatch Thrown if the credential given does not correspond to the user. auth/unauthorized-domain Thrown if the app domain is not authorized for OAuth operations for your Firebase project. Edit the list of authorized domains from the Firebase console.

                                This method does not work in a Node.js environment.

                                Parameter provider

                                The provider to authenticate. The provider has to be an OAuth provider. Non-OAuth providers like firebase.auth.EmailAuthProvider will throw an error.

                              method reload

                              reload: () => Promise<void>;
                              • Refreshes the current user, if signed in.

                              method sendEmailVerification

                              sendEmailVerification: (
                              actionCodeSettings?: auth.ActionCodeSettings
                              ) => Promise<void>;
                              • Sends a verification email to a user.

                                The verification process is completed by calling firebase.auth.Auth.applyActionCode

                                Error Codes auth/missing-android-pkg-name An Android package name must be provided if the Android app is required to be installed. auth/missing-continue-uri A continue URL must be provided in the request. auth/missing-ios-bundle-id An iOS bundle ID must be provided if an App Store ID is provided. auth/invalid-continue-uri The continue URL provided in the request is invalid. auth/unauthorized-continue-uri The domain of the continue URL is not whitelisted. Whitelist the domain in the Firebase console.

                                Parameter actionCodeSettings

                                The action code settings. If specified, the state/continue URL will be set as the "continueUrl" parameter in the email verification link. The default email verification landing page will use this to display a link to go back to the app if it is installed. If the actionCodeSettings is not specified, no URL is appended to the action URL. The state URL provided must belong to a domain that is whitelisted by the developer in the console. Otherwise an error will be thrown. Mobile app redirects will only be applicable if the developer configures and accepts the Firebase Dynamic Links terms of condition. The Android package name and iOS bundle ID will be respected only if they are configured in the same Firebase Auth project used.

                                Example 1

                                var actionCodeSettings = {
                                url: 'https://www.example.com/cart?email=user@example.com&cartId=123',
                                iOS: {
                                bundleId: 'com.example.ios'
                                },
                                android: {
                                packageName: 'com.example.android',
                                installApp: true,
                                minimumVersion: '12'
                                },
                                handleCodeInApp: true
                                };
                                firebase.auth().currentUser.sendEmailVerification(actionCodeSettings)
                                .then(function() {
                                // Verification email sent.
                                })
                                .catch(function(error) {
                                // Error occurred. Inspect error.code.
                                });

                              method toJSON

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

                                A JSON-serializable representation of this object.

                              unlink: (providerId: string) => Promise<firebase.User>;
                              • Unlinks a provider from a user account.

                                Error Codes auth/no-such-provider Thrown if the user does not have this provider linked or when the provider ID given does not exist.

                                Parameter providerId

                              method updateEmail

                              updateEmail: (newEmail: string) => Promise<void>;
                              • Updates the user's email address.

                                An email will be sent to the original email address (if it was set) that allows to revoke the email address change, in order to protect them from account hijacking.

                                Important: this is a security sensitive operation that requires the user to have recently signed in. If this requirement isn't met, ask the user to authenticate again and then call firebase.User.reauthenticateWithCredential.

                                Error Codes auth/invalid-email Thrown if the email used is invalid. auth/email-already-in-use Thrown if the email is already used by another user. auth/requires-recent-login Thrown if the user's last sign-in time does not meet the security threshold. Use firebase.User.reauthenticateWithCredential to resolve. This does not apply if the user is anonymous.

                                Parameter newEmail

                                The new email address.

                              method updatePassword

                              updatePassword: (newPassword: string) => Promise<void>;
                              • Updates the user's password.

                                Important: this is a security sensitive operation that requires the user to have recently signed in. If this requirement isn't met, ask the user to authenticate again and then call firebase.User.reauthenticateWithCredential.

                                Error Codes auth/weak-password Thrown if the password is not strong enough. auth/requires-recent-login Thrown if the user's last sign-in time does not meet the security threshold. Use firebase.User.reauthenticateWithCredential to resolve. This does not apply if the user is anonymous.

                                Parameter newPassword

                              method updatePhoneNumber

                              updatePhoneNumber: (phoneCredential: auth.AuthCredential) => Promise<void>;
                              • Updates the user's phone number.

                                Error Codes auth/invalid-verification-code Thrown if the verification code of the credential is not valid. auth/invalid-verification-id Thrown if the verification ID of the credential is not valid.

                                Parameter phoneCredential

                              method updateProfile

                              updateProfile: (profile: {
                              displayName?: string | null;
                              photoURL?: string | null;
                              }) => Promise<void>;
                              • Updates a user's profile data.

                                Parameter profile

                                The profile's displayName and photoURL to update.

                                Example 1

                                // Updates the user attributes:
                                user.updateProfile({
                                displayName: "Jane Q. User",
                                photoURL: "https://example.com/jane-q-user/profile.jpg"
                                }).then(function() {
                                // Profile updated successfully!
                                // "Jane Q. User"
                                var displayName = user.displayName;
                                // "https://example.com/jane-q-user/profile.jpg"
                                var photoURL = user.photoURL;
                                }, function(error) {
                                // An error happened.
                                });
                                // Passing a null value will delete the current attribute's value, but not
                                // passing a property won't change the current attribute's value:
                                // Let's say we're using the same user than before, after the update.
                                user.updateProfile({photoURL: null}).then(function() {
                                // Profile updated successfully!
                                // "Jane Q. User", hasn't changed.
                                var displayName = user.displayName;
                                // Now, this is null.
                                var photoURL = user.photoURL;
                                }, function(error) {
                                // An error happened.
                                });

                              method verifyBeforeUpdateEmail

                              verifyBeforeUpdateEmail: (
                              newEmail: string,
                              actionCodeSettings?: auth.ActionCodeSettings
                              ) => Promise<void>;
                              • Sends a verification email to a new email address. The user's email will be updated to the new one after being verified.

                                If you have a custom email action handler, you can complete the verification process by calling firebase.auth.Auth.applyActionCode.

                                Error Codes auth/missing-android-pkg-name An Android package name must be provided if the Android app is required to be installed. auth/missing-continue-uri A continue URL must be provided in the request. auth/missing-ios-bundle-id An iOS bundle ID must be provided if an App Store ID is provided. auth/invalid-continue-uri The continue URL provided in the request is invalid. auth/unauthorized-continue-uri The domain of the continue URL is not whitelisted. Whitelist the domain in the Firebase console.

                                Parameter newEmail

                                The email address to be verified and updated to.

                                Parameter actionCodeSettings

                                The action code settings. If specified, the state/continue URL will be set as the "continueUrl" parameter in the email verification link. The default email verification landing page will use this to display a link to go back to the app if it is installed. If the actionCodeSettings is not specified, no URL is appended to the action URL. The state URL provided must belong to a domain that is whitelisted by the developer in the console. Otherwise an error will be thrown. Mobile app redirects will only be applicable if the developer configures and accepts the Firebase Dynamic Links terms of condition. The Android package name and iOS bundle ID will be respected only if they are configured in the same Firebase Auth project used.

                                Example 1

                                var actionCodeSettings = {
                                url: 'https://www.example.com/cart?email=user@example.com&cartId=123',
                                iOS: {
                                bundleId: 'com.example.ios'
                                },
                                android: {
                                packageName: 'com.example.android',
                                installApp: true,
                                minimumVersion: '12'
                                },
                                handleCodeInApp: true
                                };
                                firebase.auth().currentUser.verifyBeforeUpdateEmail(
                                'user@example.com', actionCodeSettings)
                                .then(function() {
                                // Verification email sent.
                                })
                                .catch(function(error) {
                                // Error occurred. Inspect error.code.
                                });

                              interface UserInfo

                              interface UserInfo {}
                              • User profile information, visible only to the Firebase project's apps.

                              property displayName

                              displayName: string | null;

                                property email

                                email: string | null;

                                  property phoneNumber

                                  phoneNumber: string | null;

                                    property photoURL

                                    photoURL: string | null;

                                      property providerId

                                      providerId: string;

                                        property uid

                                        uid: string;
                                        • The user's unique ID.

                                        type CompleteFn

                                        type CompleteFn = () => void;

                                        type EmulatorMockTokenOptions

                                        type EmulatorMockTokenOptions = ({ user_id: string } | { sub: string }) &
                                        Partial<FirebaseIdToken>;

                                          type ErrorFn

                                          type ErrorFn<E = Error> = (error: E) => void;

                                          type FirebaseSignInProvider

                                          type FirebaseSignInProvider =
                                          | 'custom'
                                          | 'email'
                                          | 'password'
                                          | 'phone'
                                          | 'anonymous'
                                          | 'google.com'
                                          | 'facebook.com'
                                          | 'github.com'
                                          | 'twitter.com'
                                          | 'microsoft.com'
                                          | 'apple.com';

                                            type LogLevel

                                            type LogLevel = 'debug' | 'verbose' | 'info' | 'warn' | 'error' | 'silent';
                                            • The JS SDK supports 5 log levels and also allows a user the ability to silence the logs altogether.

                                              The order is as follows: silent < debug < verbose < info < warn < error

                                            type NextFn

                                            type NextFn<T> = (value: T) => void;

                                            type Unsubscribe

                                            type Unsubscribe = () => void;

                                            namespace firebase.analytics

                                            namespace firebase.analytics {}

                                              function isSupported

                                              isSupported: () => Promise<boolean>;
                                              • An async function that returns true if current browser context supports initialization of analytics module (firebase.analytics()).

                                                Returns false otherwise.

                                              function settings

                                              settings: (settings: SettingsOptions) => void;
                                              • Configures Firebase Analytics to use custom gtag or dataLayer names. Intended to be used if gtag.js script has been installed on this page independently of Firebase Analytics, and is using non-default names for either the gtag function or for dataLayer. Must be called before calling firebase.analytics() or it won't have any effect.

                                              interface Analytics

                                              interface Analytics {}
                                              • The Firebase Analytics service interface.

                                                Do not call this constructor directly. Instead, use .

                                              property app

                                              app: firebase.app.App;
                                              • The associated with the Analytics service instance.

                                                Example 1

                                                var app = analytics.app;

                                              method logEvent

                                              logEvent: {
                                              (
                                              eventName: 'add_payment_info',
                                              eventParams?: {
                                              [key: string]: any;
                                              coupon?: EventParams['coupon'];
                                              currency?: EventParams['currency'];
                                              items?: EventParams['items'];
                                              payment_type?: EventParams['payment_type'];
                                              value?: EventParams['value'];
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'add_shipping_info',
                                              eventParams?: {
                                              [key: string]: any;
                                              coupon?: string;
                                              currency?: string;
                                              items?: Item[];
                                              shipping_tier?: string;
                                              value?: number;
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'add_to_cart' | 'add_to_wishlist' | 'remove_from_cart',
                                              eventParams?: {
                                              [key: string]: any;
                                              currency?: string;
                                              value?: number;
                                              items?: Item[];
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'begin_checkout',
                                              eventParams?: {
                                              [key: string]: any;
                                              currency?: string;
                                              coupon?: string;
                                              value?: number;
                                              items?: Item[];
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'checkout_progress',
                                              eventParams?: {
                                              [key: string]: any;
                                              currency?: string;
                                              coupon?: string;
                                              value?: number;
                                              items?: Item[];
                                              checkout_step?: number;
                                              checkout_option?: string;
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'exception',
                                              eventParams?: {
                                              [key: string]: any;
                                              description?: string;
                                              fatal?: boolean;
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'generate_lead',
                                              eventParams?: { [key: string]: any; value?: number; currency?: string },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'login',
                                              eventParams?: { [key: string]: any; method?: string },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'page_view',
                                              eventParams?: {
                                              [key: string]: any;
                                              page_title?: string;
                                              page_location?: string;
                                              page_path?: string;
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'purchase' | 'refund',
                                              eventParams?: {
                                              [key: string]: any;
                                              value?: number;
                                              currency?: string;
                                              transaction_id: string;
                                              tax?: Currency;
                                              shipping?: Currency;
                                              items?: Item[];
                                              coupon?: string;
                                              affiliation?: string;
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'screen_view',
                                              eventParams?: {
                                              [key: string]: any;
                                              firebase_screen: string;
                                              firebase_screen_class: string;
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'search' | 'view_search_results',
                                              eventParams?: { [key: string]: any; search_term?: string },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'select_content',
                                              eventParams?: {
                                              [key: string]: any;
                                              content_type?: string;
                                              item_id?: string;
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'select_item',
                                              eventParams?: {
                                              [key: string]: any;
                                              items?: Item[];
                                              item_list_name?: string;
                                              item_list_id?: string;
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'select_promotion' | 'view_promotion',
                                              eventParams?: {
                                              [key: string]: any;
                                              items?: Item[];
                                              promotion_id?: string;
                                              promotion_name?: string;
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'set_checkout_option',
                                              eventParams?: {
                                              [key: string]: any;
                                              checkout_step?: number;
                                              checkout_option?: string;
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'share',
                                              eventParams?: {
                                              [key: string]: any;
                                              method?: string;
                                              content_type?: string;
                                              item_id?: string;
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'sign_up',
                                              eventParams?: { [key: string]: any; method?: string },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'timing_complete',
                                              eventParams?: {
                                              [key: string]: any;
                                              name: string;
                                              value: number;
                                              event_category?: string;
                                              event_label?: string;
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'view_cart' | 'view_item',
                                              eventParams?: {
                                              [key: string]: any;
                                              currency?: string;
                                              items?: Item[];
                                              value?: number;
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              (
                                              eventName: 'view_item_list',
                                              eventParams?: {
                                              [key: string]: any;
                                              items?: Item[];
                                              item_list_name?: string;
                                              item_list_id?: string;
                                              },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              <T extends string>(
                                              eventName: CustomEventName<T>,
                                              eventParams?: { [key: string]: any },
                                              options?: AnalyticsCallOptions
                                              ): void;
                                              };
                                              • Sends analytics event with given eventParams. This method automatically associates this logged event with this Firebase web app instance on this device. List of recommended event parameters can be found in the GA4 reference documentation.

                                              • Sends analytics event with given eventParams. This method automatically associates this logged event with this Firebase web app instance on this device. See Measure exceptions.

                                              • Sends analytics event with given eventParams. This method automatically associates this logged event with this Firebase web app instance on this device. See Page views.

                                              • Sends analytics event with given eventParams. This method automatically associates this logged event with this Firebase web app instance on this device. See Track Screenviews.

                                              method setAnalyticsCollectionEnabled

                                              setAnalyticsCollectionEnabled: (enabled: boolean) => void;
                                              • Sets whether analytics collection is enabled for this app on this device. window['ga-disable-analyticsId'] = true;

                                              method setCurrentScreen

                                              setCurrentScreen: (screenName: string, options?: AnalyticsCallOptions) => void;
                                              • Use gtag 'config' command to set 'screen_name'.

                                                Deprecated

                                                Use logEvent with eventName as 'screen_view' and add relevant eventParams. See Track Screenviews.

                                              method setUserId

                                              setUserId: (id: string, options?: AnalyticsCallOptions) => void;
                                              • Use gtag 'config' command to set 'user_id'.

                                              method setUserProperties

                                              setUserProperties: (
                                              properties: CustomParams,
                                              options?: AnalyticsCallOptions
                                              ) => void;
                                              • Use gtag 'config' command to set all params specified.

                                              interface AnalyticsCallOptions

                                              interface AnalyticsCallOptions {}
                                              • Additional options that can be passed to Firebase Analytics method calls such as logEvent, setCurrentScreen, etc.

                                              property global

                                              global: boolean;
                                              • If true, this config or event call applies globally to all analytics properties on the page.

                                              interface ControlParams

                                              interface ControlParams {}
                                              • Standard gtag.js control parameters. For more information, see .

                                              property event_callback

                                              event_callback?: () => void;

                                                property event_timeout

                                                event_timeout?: number;

                                                  property groups

                                                  groups?: string | string[];

                                                    property send_to

                                                    send_to?: string | string[];

                                                      interface CustomParams

                                                      interface CustomParams {}
                                                      • Any custom params the user may pass to gtag.js.

                                                      index signature

                                                      [key: string]: any;

                                                        interface EventParams

                                                        interface EventParams {}
                                                        • Standard gtag.js event parameters. For more information, see .

                                                        property affiliation

                                                        affiliation?: string;

                                                          property checkout_option

                                                          checkout_option?: string;

                                                            property checkout_step

                                                            checkout_step?: number;

                                                              property content_type

                                                              content_type?: string;

                                                                property coupon

                                                                coupon?: string;

                                                                  property currency

                                                                  currency?: string;

                                                                    property description

                                                                    description?: string;

                                                                      property event_category

                                                                      event_category: string;

                                                                        property event_label

                                                                        event_label?: string;

                                                                          property fatal

                                                                          fatal?: boolean;

                                                                            property firebase_screen

                                                                            firebase_screen?: string;
                                                                            • Firebase-specific. Use to log a screen_name to Firebase Analytics.

                                                                            property firebase_screen_class

                                                                            firebase_screen_class?: string;
                                                                            • Firebase-specific. Use to log a screen_class to Firebase Analytics.

                                                                            property item_id

                                                                            item_id?: string;

                                                                              property item_list_id

                                                                              item_list_id?: string;

                                                                                property item_list_name

                                                                                item_list_name?: string;

                                                                                  property items

                                                                                  items?: Item[];

                                                                                    property method

                                                                                    method?: string;

                                                                                      property number

                                                                                      number?: string;

                                                                                        property payment_type

                                                                                        payment_type?: string;

                                                                                          property promotion_id

                                                                                          promotion_id?: string;

                                                                                            property promotion_name

                                                                                            promotion_name?: string;

                                                                                              property promotions

                                                                                              promotions?: Promotion[];

                                                                                                property screen_name

                                                                                                screen_name?: string;

                                                                                                  property search_term

                                                                                                  search_term?: string;

                                                                                                    property shipping

                                                                                                    shipping?: Currency;

                                                                                                      property shipping_tier

                                                                                                      shipping_tier?: string;

                                                                                                        property tax

                                                                                                        tax?: Currency;

                                                                                                          property transaction_id

                                                                                                          transaction_id?: string;

                                                                                                            property value

                                                                                                            value?: number;

                                                                                                              interface Item

                                                                                                              interface Item {}

                                                                                                                property affiliation

                                                                                                                affiliation?: string;

                                                                                                                  property brand

                                                                                                                  brand?: string;
                                                                                                                  • Deprecated

                                                                                                                    Use item_brand instead.

                                                                                                                  property category

                                                                                                                  category?: string;
                                                                                                                  • Deprecated

                                                                                                                    Use item_category instead.

                                                                                                                  property coupon

                                                                                                                  coupon?: string;

                                                                                                                    property creative_name

                                                                                                                    creative_name?: string;

                                                                                                                      property creative_slot

                                                                                                                      creative_slot?: string;

                                                                                                                        property discount

                                                                                                                        discount?: Currency;

                                                                                                                          property id

                                                                                                                          id?: string;
                                                                                                                          • Deprecated

                                                                                                                            Use item_id instead.

                                                                                                                          property index

                                                                                                                          index?: number;

                                                                                                                            property item_brand

                                                                                                                            item_brand?: string;

                                                                                                                              property item_category

                                                                                                                              item_category?: string;

                                                                                                                                property item_category2

                                                                                                                                item_category2?: string;

                                                                                                                                  property item_category3

                                                                                                                                  item_category3?: string;

                                                                                                                                    property item_category4

                                                                                                                                    item_category4?: string;

                                                                                                                                      property item_category5

                                                                                                                                      item_category5?: string;

                                                                                                                                        property item_id

                                                                                                                                        item_id?: string;

                                                                                                                                          property item_list_id

                                                                                                                                          item_list_id?: string;

                                                                                                                                            property item_list_name

                                                                                                                                            item_list_name?: string;

                                                                                                                                              property item_name

                                                                                                                                              item_name?: string;

                                                                                                                                                property item_variant

                                                                                                                                                item_variant?: string;

                                                                                                                                                  property location_id

                                                                                                                                                  location_id?: string;

                                                                                                                                                    property name

                                                                                                                                                    name?: string;
                                                                                                                                                    • Deprecated

                                                                                                                                                      Use item_name instead.

                                                                                                                                                    property price

                                                                                                                                                    price?: Currency;

                                                                                                                                                      property promotion_id

                                                                                                                                                      promotion_id?: string;

                                                                                                                                                        property promotion_name

                                                                                                                                                        promotion_name?: string;

                                                                                                                                                          property quantity

                                                                                                                                                          quantity?: number;

                                                                                                                                                            interface Promotion

                                                                                                                                                            interface Promotion {}
                                                                                                                                                            • Deprecated

                                                                                                                                                              Use Item instead.

                                                                                                                                                            property creative_name

                                                                                                                                                            creative_name?: string;

                                                                                                                                                              property creative_slot

                                                                                                                                                              creative_slot?: string;

                                                                                                                                                                property id

                                                                                                                                                                id?: string;

                                                                                                                                                                  property name

                                                                                                                                                                  name?: string;

                                                                                                                                                                    interface SettingsOptions

                                                                                                                                                                    interface SettingsOptions {}
                                                                                                                                                                    • Specifies custom options for your Firebase Analytics instance. You must set these before initializing firebase.analytics().

                                                                                                                                                                    property dataLayerName

                                                                                                                                                                    dataLayerName?: string;
                                                                                                                                                                    • Sets custom name for dataLayer array used by gtag.

                                                                                                                                                                    property gtagName

                                                                                                                                                                    gtagName?: string;
                                                                                                                                                                    • Sets custom name for gtag function.

                                                                                                                                                                    enum EventName

                                                                                                                                                                    enum EventName {
                                                                                                                                                                    ADD_PAYMENT_INFO = 'add_payment_info',
                                                                                                                                                                    ADD_SHIPPING_INFO = 'add_shipping_info',
                                                                                                                                                                    ADD_TO_CART = 'add_to_cart',
                                                                                                                                                                    ADD_TO_WISHLIST = 'add_to_wishlist',
                                                                                                                                                                    BEGIN_CHECKOUT = 'begin_checkout',
                                                                                                                                                                    CHECKOUT_PROGRESS = 'checkout_progress',
                                                                                                                                                                    EXCEPTION = 'exception',
                                                                                                                                                                    GENERATE_LEAD = 'generate_lead',
                                                                                                                                                                    LOGIN = 'login',
                                                                                                                                                                    PAGE_VIEW = 'page_view',
                                                                                                                                                                    PURCHASE = 'purchase',
                                                                                                                                                                    REFUND = 'refund',
                                                                                                                                                                    REMOVE_FROM_CART = 'remove_from_cart',
                                                                                                                                                                    SCREEN_VIEW = 'screen_view',
                                                                                                                                                                    SEARCH = 'search',
                                                                                                                                                                    SELECT_CONTENT = 'select_content',
                                                                                                                                                                    SELECT_ITEM = 'select_item',
                                                                                                                                                                    SELECT_PROMOTION = 'select_promotion',
                                                                                                                                                                    SET_CHECKOUT_OPTION = 'set_checkout_option',
                                                                                                                                                                    SHARE = 'share',
                                                                                                                                                                    SIGN_UP = 'sign_up',
                                                                                                                                                                    TIMING_COMPLETE = 'timing_complete',
                                                                                                                                                                    VIEW_CART = 'view_cart',
                                                                                                                                                                    VIEW_ITEM = 'view_item',
                                                                                                                                                                    VIEW_ITEM_LIST = 'view_item_list',
                                                                                                                                                                    VIEW_PROMOTION = 'view_promotion',
                                                                                                                                                                    VIEW_SEARCH_RESULTS = 'view_search_results',
                                                                                                                                                                    }
                                                                                                                                                                    • Enum of standard gtag.js event names provided for convenient developer usage. logEvent will also accept any custom string and interpret it as a custom event name.

                                                                                                                                                                    member ADD_PAYMENT_INFO

                                                                                                                                                                    ADD_PAYMENT_INFO = 'add_payment_info'

                                                                                                                                                                      member ADD_SHIPPING_INFO

                                                                                                                                                                      ADD_SHIPPING_INFO = 'add_shipping_info'

                                                                                                                                                                        member ADD_TO_CART

                                                                                                                                                                        ADD_TO_CART = 'add_to_cart'

                                                                                                                                                                          member ADD_TO_WISHLIST

                                                                                                                                                                          ADD_TO_WISHLIST = 'add_to_wishlist'

                                                                                                                                                                            member BEGIN_CHECKOUT

                                                                                                                                                                            BEGIN_CHECKOUT = 'begin_checkout'

                                                                                                                                                                              member CHECKOUT_PROGRESS

                                                                                                                                                                              CHECKOUT_PROGRESS = 'checkout_progress'
                                                                                                                                                                              • Deprecated

                                                                                                                                                                              member EXCEPTION

                                                                                                                                                                              EXCEPTION = 'exception'

                                                                                                                                                                                member GENERATE_LEAD

                                                                                                                                                                                GENERATE_LEAD = 'generate_lead'

                                                                                                                                                                                  member LOGIN

                                                                                                                                                                                  LOGIN = 'login'

                                                                                                                                                                                    member PAGE_VIEW

                                                                                                                                                                                    PAGE_VIEW = 'page_view'

                                                                                                                                                                                      member PURCHASE

                                                                                                                                                                                      PURCHASE = 'purchase'

                                                                                                                                                                                        member REFUND

                                                                                                                                                                                        REFUND = 'refund'

                                                                                                                                                                                          member REMOVE_FROM_CART

                                                                                                                                                                                          REMOVE_FROM_CART = 'remove_from_cart'

                                                                                                                                                                                            member SCREEN_VIEW

                                                                                                                                                                                            SCREEN_VIEW = 'screen_view'

                                                                                                                                                                                              member SEARCH

                                                                                                                                                                                              SEARCH = 'search'

                                                                                                                                                                                                member SELECT_CONTENT

                                                                                                                                                                                                SELECT_CONTENT = 'select_content'

                                                                                                                                                                                                  member SELECT_ITEM

                                                                                                                                                                                                  SELECT_ITEM = 'select_item'

                                                                                                                                                                                                    member SELECT_PROMOTION

                                                                                                                                                                                                    SELECT_PROMOTION = 'select_promotion'

                                                                                                                                                                                                      member SET_CHECKOUT_OPTION

                                                                                                                                                                                                      SET_CHECKOUT_OPTION = 'set_checkout_option'
                                                                                                                                                                                                      • Deprecated

                                                                                                                                                                                                      member SHARE

                                                                                                                                                                                                      SHARE = 'share'

                                                                                                                                                                                                        member SIGN_UP

                                                                                                                                                                                                        SIGN_UP = 'sign_up'

                                                                                                                                                                                                          member TIMING_COMPLETE

                                                                                                                                                                                                          TIMING_COMPLETE = 'timing_complete'

                                                                                                                                                                                                            member VIEW_CART

                                                                                                                                                                                                            VIEW_CART = 'view_cart'

                                                                                                                                                                                                              member VIEW_ITEM

                                                                                                                                                                                                              VIEW_ITEM = 'view_item'

                                                                                                                                                                                                                member VIEW_ITEM_LIST

                                                                                                                                                                                                                VIEW_ITEM_LIST = 'view_item_list'

                                                                                                                                                                                                                  member VIEW_PROMOTION

                                                                                                                                                                                                                  VIEW_PROMOTION = 'view_promotion'

                                                                                                                                                                                                                    member VIEW_SEARCH_RESULTS

                                                                                                                                                                                                                    VIEW_SEARCH_RESULTS = 'view_search_results'

                                                                                                                                                                                                                      type Currency

                                                                                                                                                                                                                      type Currency = string | number;

                                                                                                                                                                                                                        type CustomEventName

                                                                                                                                                                                                                        type CustomEventName<T> = T extends EventNameString ? never : T;

                                                                                                                                                                                                                          type EventNameString

                                                                                                                                                                                                                          type EventNameString =
                                                                                                                                                                                                                          | 'add_payment_info'
                                                                                                                                                                                                                          | 'add_shipping_info'
                                                                                                                                                                                                                          | 'add_to_cart'
                                                                                                                                                                                                                          | 'add_to_wishlist'
                                                                                                                                                                                                                          | 'begin_checkout'
                                                                                                                                                                                                                          | 'checkout_progress'
                                                                                                                                                                                                                          | 'exception'
                                                                                                                                                                                                                          | 'generate_lead'
                                                                                                                                                                                                                          | 'login'
                                                                                                                                                                                                                          | 'page_view'
                                                                                                                                                                                                                          | 'purchase'
                                                                                                                                                                                                                          | 'refund'
                                                                                                                                                                                                                          | 'remove_from_cart'
                                                                                                                                                                                                                          | 'screen_view'
                                                                                                                                                                                                                          | 'search'
                                                                                                                                                                                                                          | 'select_content'
                                                                                                                                                                                                                          | 'select_item'
                                                                                                                                                                                                                          | 'select_promotion'
                                                                                                                                                                                                                          | 'set_checkout_option'
                                                                                                                                                                                                                          | 'share'
                                                                                                                                                                                                                          | 'sign_up'
                                                                                                                                                                                                                          | 'timing_complete'
                                                                                                                                                                                                                          | 'view_cart'
                                                                                                                                                                                                                          | 'view_item'
                                                                                                                                                                                                                          | 'view_item_list'
                                                                                                                                                                                                                          | 'view_promotion'
                                                                                                                                                                                                                          | 'view_search_results';
                                                                                                                                                                                                                          • Type for standard gtag.js event names. logEvent also accepts any custom string and interprets it as a custom event name.

                                                                                                                                                                                                                          namespace firebase.app

                                                                                                                                                                                                                          namespace firebase.app {}

                                                                                                                                                                                                                            interface App

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

                                                                                                                                                                                                                              Do not call this constructor directly. Instead, use `firebase.initializeApp()` to create an app.

                                                                                                                                                                                                                            property automaticDataCollectionEnabled

                                                                                                                                                                                                                            automaticDataCollectionEnabled: boolean;
                                                                                                                                                                                                                            • The settable config flag for GDPR opt-in/opt-out

                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                            name: string;
                                                                                                                                                                                                                            • The (read-only) name for this app.

                                                                                                                                                                                                                              The default app's name is "[DEFAULT]".

                                                                                                                                                                                                                              Example 1

                                                                                                                                                                                                                              // The default app's name is "[DEFAULT]"
                                                                                                                                                                                                                              firebase.initializeApp(defaultAppConfig);
                                                                                                                                                                                                                              console.log(firebase.app().name); // "[DEFAULT]"

                                                                                                                                                                                                                              Example 2

                                                                                                                                                                                                                              // A named app's name is what you provide to initializeApp()
                                                                                                                                                                                                                              var otherApp = firebase.initializeApp(otherAppConfig, "other");
                                                                                                                                                                                                                              console.log(otherApp.name); // "other"

                                                                                                                                                                                                                            property options

                                                                                                                                                                                                                            options: Object;
                                                                                                                                                                                                                            • The (read-only) configuration options for this app. These are the original parameters given in .

                                                                                                                                                                                                                              Example 1

                                                                                                                                                                                                                              var app = firebase.initializeApp(config);
                                                                                                                                                                                                                              console.log(app.options.databaseURL === config.databaseURL); // true

                                                                                                                                                                                                                            method analytics

                                                                                                                                                                                                                            analytics: () => firebase.analytics.Analytics;
                                                                                                                                                                                                                            • Gets the service for the current app. If the current app is not the default one, throws an error.

                                                                                                                                                                                                                              The Analytics SDK does not work in a Node.js environment.

                                                                                                                                                                                                                              Example 1

                                                                                                                                                                                                                              const analytics = app.analytics();
                                                                                                                                                                                                                              // The above is shorthand for:
                                                                                                                                                                                                                              // const analytics = firebase.analytics(app);

                                                                                                                                                                                                                            method appCheck

                                                                                                                                                                                                                            appCheck: () => firebase.appCheck.AppCheck;

                                                                                                                                                                                                                              method auth

                                                                                                                                                                                                                              auth: () => firebase.auth.Auth;
                                                                                                                                                                                                                              • Gets the service for the current app.

                                                                                                                                                                                                                                Example 1

                                                                                                                                                                                                                                var auth = app.auth();
                                                                                                                                                                                                                                // The above is shorthand for:
                                                                                                                                                                                                                                // var auth = firebase.auth(app);

                                                                                                                                                                                                                              method database

                                                                                                                                                                                                                              database: (url?: string) => firebase.database.Database;
                                                                                                                                                                                                                              • Gets the service for the current app.

                                                                                                                                                                                                                                Example 1

                                                                                                                                                                                                                                var database = app.database();
                                                                                                                                                                                                                                // The above is shorthand for:
                                                                                                                                                                                                                                // var database = firebase.database(app);

                                                                                                                                                                                                                              method delete

                                                                                                                                                                                                                              delete: () => Promise<any>;
                                                                                                                                                                                                                              • Renders this app unusable and frees the resources of all associated services.

                                                                                                                                                                                                                                Example 1

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

                                                                                                                                                                                                                              method firestore

                                                                                                                                                                                                                              firestore: () => firebase.firestore.Firestore;

                                                                                                                                                                                                                                method functions

                                                                                                                                                                                                                                functions: (regionOrCustomDomain?: string) => firebase.functions.Functions;

                                                                                                                                                                                                                                  method installations

                                                                                                                                                                                                                                  installations: () => firebase.installations.Installations;
                                                                                                                                                                                                                                  • Gets the service for the current app.

                                                                                                                                                                                                                                    The Installations SDK does not work in a Node.js environment.

                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                    const installations = app.installations();
                                                                                                                                                                                                                                    // The above is shorthand for:
                                                                                                                                                                                                                                    // const installations = firebase.installations(app);

                                                                                                                                                                                                                                  method messaging

                                                                                                                                                                                                                                  messaging: () => firebase.messaging.Messaging;
                                                                                                                                                                                                                                  • Gets the service for the current app.

                                                                                                                                                                                                                                    The Messaging SDK does not work in a Node.js environment.

                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                    var messaging = app.messaging();
                                                                                                                                                                                                                                    // The above is shorthand for:
                                                                                                                                                                                                                                    // var messaging = firebase.messaging(app);

                                                                                                                                                                                                                                  method performance

                                                                                                                                                                                                                                  performance: () => firebase.performance.Performance;
                                                                                                                                                                                                                                  • Gets the service for the current app. If the current app is not the default one, throws an error.

                                                                                                                                                                                                                                    The Performance SDK does not work in a Node.js environment.

                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                    const perf = app.performance();
                                                                                                                                                                                                                                    // The above is shorthand for:
                                                                                                                                                                                                                                    // const perf = firebase.performance(app);

                                                                                                                                                                                                                                  method remoteConfig

                                                                                                                                                                                                                                  remoteConfig: () => firebase.remoteConfig.RemoteConfig;
                                                                                                                                                                                                                                  • Gets the instance.

                                                                                                                                                                                                                                    The Remote Config SDK does not work in a Node.js environment.

                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                    const rc = app.remoteConfig();
                                                                                                                                                                                                                                    // The above is shorthand for:
                                                                                                                                                                                                                                    // const rc = firebase.remoteConfig(app);

                                                                                                                                                                                                                                  method storage

                                                                                                                                                                                                                                  storage: (url?: string) => firebase.storage.Storage;
                                                                                                                                                                                                                                  • Gets the service for the current app, optionally initialized with a custom storage bucket.

                                                                                                                                                                                                                                    Parameter url

                                                                                                                                                                                                                                    The gs:// url to your Firebase Storage Bucket. If not passed, uses the app's default Storage Bucket.

                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                    var storage = app.storage();
                                                                                                                                                                                                                                    // The above is shorthand for:
                                                                                                                                                                                                                                    // var storage = firebase.storage(app);

                                                                                                                                                                                                                                    Example 2

                                                                                                                                                                                                                                    var storage = app.storage("gs://your-app.appspot.com");

                                                                                                                                                                                                                                  namespace firebase.appCheck

                                                                                                                                                                                                                                  namespace firebase.appCheck {}

                                                                                                                                                                                                                                    class CustomProvider

                                                                                                                                                                                                                                    class CustomProvider {}

                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                      constructor(options: CustomProviderOptions);
                                                                                                                                                                                                                                      • Parameter options

                                                                                                                                                                                                                                        Options for creating the custom provider.

                                                                                                                                                                                                                                      class ReCaptchaEnterpriseProvider

                                                                                                                                                                                                                                      class ReCaptchaEnterpriseProvider {}

                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                        constructor(keyId: string);
                                                                                                                                                                                                                                        • Parameter keyId

                                                                                                                                                                                                                                          reCAPTCHA Enterprise key ID.

                                                                                                                                                                                                                                        class ReCaptchaV3Provider

                                                                                                                                                                                                                                        class ReCaptchaV3Provider {}

                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                          constructor(siteKey: string);
                                                                                                                                                                                                                                          • Parameter siteKey

                                                                                                                                                                                                                                            reCAPTCHA v3 site key (public key).

                                                                                                                                                                                                                                          interface AppCheck

                                                                                                                                                                                                                                          interface AppCheck {}
                                                                                                                                                                                                                                          • The Firebase AppCheck service interface.

                                                                                                                                                                                                                                            Do not call this constructor directly. Instead, use .

                                                                                                                                                                                                                                          method activate

                                                                                                                                                                                                                                          activate: (
                                                                                                                                                                                                                                          provider:
                                                                                                                                                                                                                                          | string
                                                                                                                                                                                                                                          | ReCaptchaV3Provider
                                                                                                                                                                                                                                          | ReCaptchaEnterpriseProvider
                                                                                                                                                                                                                                          | CustomProvider
                                                                                                                                                                                                                                          | AppCheckProvider
                                                                                                                                                                                                                                          | { getToken: () => AppCheckToken },
                                                                                                                                                                                                                                          isTokenAutoRefreshEnabled?: boolean
                                                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                                                          • Activate AppCheck

                                                                                                                                                                                                                                            Parameter provider

                                                                                                                                                                                                                                            This can be a ReCaptchaV3Provider instance, a ReCaptchaEnterpriseProvider instance, a CustomProvider instance, an object with a custom getToken() method, or a reCAPTCHA site key.

                                                                                                                                                                                                                                            Parameter isTokenAutoRefreshEnabled

                                                                                                                                                                                                                                            If true, the SDK automatically refreshes App Check tokens as needed. If undefined, defaults to the value of app.automaticDataCollectionEnabled, which defaults to false and can be set in the app config.

                                                                                                                                                                                                                                          method getToken

                                                                                                                                                                                                                                          getToken: (forceRefresh?: boolean) => Promise<AppCheckTokenResult>;
                                                                                                                                                                                                                                          • Get the current App Check token. Attaches to the most recent in-flight request if one is present. Returns null if no token is present and no token requests are in-flight.

                                                                                                                                                                                                                                            Parameter forceRefresh

                                                                                                                                                                                                                                            If true, will always try to fetch a fresh token. If false, will use a cached token if found in storage.

                                                                                                                                                                                                                                          method onTokenChanged

                                                                                                                                                                                                                                          onTokenChanged: {
                                                                                                                                                                                                                                          (observer: {
                                                                                                                                                                                                                                          next: (tokenResult: AppCheckTokenResult) => void;
                                                                                                                                                                                                                                          error?: (error: Error) => void;
                                                                                                                                                                                                                                          complete?: () => void;
                                                                                                                                                                                                                                          }): Unsubscribe;
                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                          onNext: (tokenResult: AppCheckTokenResult) => void,
                                                                                                                                                                                                                                          onError?: (error: Error) => void,
                                                                                                                                                                                                                                          onCompletion?: () => void
                                                                                                                                                                                                                                          ): Unsubscribe;
                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                          • Registers a listener to changes in the token state. There can be more than one listener registered at the same time for one or more App Check instances. The listeners call back on the UI thread whenever the current token associated with this App Check instance changes.

                                                                                                                                                                                                                                            Parameter observer

                                                                                                                                                                                                                                            An object with next, error, and complete properties. next is called with an whenever the token changes. error is optional and is called if an error is thrown by the listener (the next function). complete is unused, as the token stream is unending.

                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                            A function that unsubscribes this listener.

                                                                                                                                                                                                                                          • Registers a listener to changes in the token state. There can be more than one listener registered at the same time for one or more App Check instances. The listeners call back on the UI thread whenever the current token associated with this App Check instance changes.

                                                                                                                                                                                                                                            Parameter onNext

                                                                                                                                                                                                                                            When the token changes, this function is called with aa .

                                                                                                                                                                                                                                            Parameter onError

                                                                                                                                                                                                                                            Optional. Called if there is an error thrown by the listener (the onNext function).

                                                                                                                                                                                                                                            Parameter onCompletion

                                                                                                                                                                                                                                            Currently unused, as the token stream is unending.

                                                                                                                                                                                                                                            Returns

                                                                                                                                                                                                                                            A function that unsubscribes this listener.

                                                                                                                                                                                                                                          method setTokenAutoRefreshEnabled

                                                                                                                                                                                                                                          setTokenAutoRefreshEnabled: (isTokenAutoRefreshEnabled: boolean) => void;
                                                                                                                                                                                                                                          • Parameter isTokenAutoRefreshEnabled

                                                                                                                                                                                                                                            If true, the SDK automatically refreshes App Check tokens as needed. This overrides any value set during activate().

                                                                                                                                                                                                                                          interface AppCheckProvider

                                                                                                                                                                                                                                          interface AppCheckProvider {}
                                                                                                                                                                                                                                          • An App Check provider. This can be either the built-in reCAPTCHA provider or a custom provider. For more on custom providers, see https://firebase.google.com/docs/app-check/web-custom-provider

                                                                                                                                                                                                                                          method getToken

                                                                                                                                                                                                                                          getToken: () => Promise<AppCheckToken>;
                                                                                                                                                                                                                                          • Returns an AppCheck token.

                                                                                                                                                                                                                                          interface AppCheckToken

                                                                                                                                                                                                                                          interface AppCheckToken {}
                                                                                                                                                                                                                                          • The token returned from an .

                                                                                                                                                                                                                                          property expireTimeMillis

                                                                                                                                                                                                                                          readonly expireTimeMillis: number;
                                                                                                                                                                                                                                          • The local timestamp after which the token will expire.

                                                                                                                                                                                                                                          property token

                                                                                                                                                                                                                                          readonly token: string;
                                                                                                                                                                                                                                          • The token string in JWT format.

                                                                                                                                                                                                                                          interface AppCheckTokenResult

                                                                                                                                                                                                                                          interface AppCheckTokenResult {}
                                                                                                                                                                                                                                          • Result returned by .

                                                                                                                                                                                                                                          property token

                                                                                                                                                                                                                                          token: string;

                                                                                                                                                                                                                                            interface CustomProviderOptions

                                                                                                                                                                                                                                            interface CustomProviderOptions {}
                                                                                                                                                                                                                                            • Options when creating a CustomProvider.

                                                                                                                                                                                                                                            property getToken

                                                                                                                                                                                                                                            getToken: () => Promise<AppCheckToken>;
                                                                                                                                                                                                                                            • Function to get an App Check token through a custom provider service.

                                                                                                                                                                                                                                            namespace firebase.auth

                                                                                                                                                                                                                                            namespace firebase.auth {}

                                                                                                                                                                                                                                              class ActionCodeURL

                                                                                                                                                                                                                                              class ActionCodeURL {}
                                                                                                                                                                                                                                              • A utility class to parse email action URLs.

                                                                                                                                                                                                                                              property apiKey

                                                                                                                                                                                                                                              apiKey: string;
                                                                                                                                                                                                                                              • The API key of the email action link.

                                                                                                                                                                                                                                              property code

                                                                                                                                                                                                                                              code: string;
                                                                                                                                                                                                                                              • The action code of the email action link.

                                                                                                                                                                                                                                              property continueUrl

                                                                                                                                                                                                                                              continueUrl: string;
                                                                                                                                                                                                                                              • The continue URL of the email action link. Null if not provided.

                                                                                                                                                                                                                                              property languageCode

                                                                                                                                                                                                                                              languageCode: string;
                                                                                                                                                                                                                                              • The language code of the email action link. Null if not provided.

                                                                                                                                                                                                                                              property operation

                                                                                                                                                                                                                                              operation: string;

                                                                                                                                                                                                                                              property tenantId

                                                                                                                                                                                                                                              tenantId: string;
                                                                                                                                                                                                                                              • The tenant ID of the email action link. Null if the email action is from the parent project.

                                                                                                                                                                                                                                              static parseLink: (link: string) => ActionCodeURL;
                                                                                                                                                                                                                                              • Parses the email action link string and returns an ActionCodeURL object if the link is valid, otherwise returns null.

                                                                                                                                                                                                                                                Parameter link

                                                                                                                                                                                                                                                The email action link string. The ActionCodeURL object, or null if the link is invalid.

                                                                                                                                                                                                                                              class AuthCredential

                                                                                                                                                                                                                                              abstract class AuthCredential {}
                                                                                                                                                                                                                                              • Interface that represents the credentials returned by an auth provider. Implementations specify the details about each auth provider's credential requirements.

                                                                                                                                                                                                                                              property providerId

                                                                                                                                                                                                                                              providerId: string;
                                                                                                                                                                                                                                              • The authentication provider ID for the credential. For example, 'facebook.com', or 'google.com'.

                                                                                                                                                                                                                                              property signInMethod

                                                                                                                                                                                                                                              signInMethod: string;

                                                                                                                                                                                                                                              method fromJSON

                                                                                                                                                                                                                                              static fromJSON: (json: Object | string) => AuthCredential;
                                                                                                                                                                                                                                              • Static method to deserialize a JSON representation of an object into an firebase.auth.AuthCredential. Input can be either Object or the stringified representation of the object. When string is provided, JSON.parse would be called first. If the JSON input does not represent anAuthCredential, null is returned.

                                                                                                                                                                                                                                                Parameter json

                                                                                                                                                                                                                                                The plain object representation of an AuthCredential.

                                                                                                                                                                                                                                              method toJSON

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

                                                                                                                                                                                                                                              class EmailAuthProvider

                                                                                                                                                                                                                                              class EmailAuthProvider extends EmailAuthProvider_Instance {}
                                                                                                                                                                                                                                              static EMAIL_LINK_SIGN_IN_METHOD: string;

                                                                                                                                                                                                                                              property EMAIL_PASSWORD_SIGN_IN_METHOD

                                                                                                                                                                                                                                              static EMAIL_PASSWORD_SIGN_IN_METHOD: string;

                                                                                                                                                                                                                                              property PROVIDER_ID

                                                                                                                                                                                                                                              static PROVIDER_ID: string;

                                                                                                                                                                                                                                                method credential

                                                                                                                                                                                                                                                static credential: (email: string, password: string) => AuthCredential;
                                                                                                                                                                                                                                                • Parameter email

                                                                                                                                                                                                                                                  Email address.

                                                                                                                                                                                                                                                  Parameter password

                                                                                                                                                                                                                                                  User account password. The auth provider credential.

                                                                                                                                                                                                                                                  Example 1

                                                                                                                                                                                                                                                  var cred = firebase.auth.EmailAuthProvider.credential(
                                                                                                                                                                                                                                                  email,
                                                                                                                                                                                                                                                  password
                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                static credentialWithLink: (email: string, emailLink: string) => AuthCredential;
                                                                                                                                                                                                                                                • Initialize an EmailAuthProvider credential using an email and an email link after a sign in with email link operation.

                                                                                                                                                                                                                                                  Parameter email

                                                                                                                                                                                                                                                  Email address.

                                                                                                                                                                                                                                                  Parameter emailLink

                                                                                                                                                                                                                                                  Sign-in email link. The auth provider credential.

                                                                                                                                                                                                                                                  Example 1

                                                                                                                                                                                                                                                  var cred = firebase.auth.EmailAuthProvider.credentialWithLink(
                                                                                                                                                                                                                                                  email,
                                                                                                                                                                                                                                                  emailLink
                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                class EmailAuthProvider_Instance

                                                                                                                                                                                                                                                class EmailAuthProvider_Instance implements firebase.auth.AuthProvider {}

                                                                                                                                                                                                                                                property providerId

                                                                                                                                                                                                                                                providerId: string;

                                                                                                                                                                                                                                                  class FacebookAuthProvider

                                                                                                                                                                                                                                                  class FacebookAuthProvider extends FacebookAuthProvider_Instance {}
                                                                                                                                                                                                                                                  • Facebook auth provider.

                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                    // Sign in using a redirect.
                                                                                                                                                                                                                                                    firebase.auth().getRedirectResult().then(function(result) {
                                                                                                                                                                                                                                                    if (result.credential) {
                                                                                                                                                                                                                                                    // This gives you a Google Access Token.
                                                                                                                                                                                                                                                    var token = result.credential.accessToken;
                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                    var user = result.user;
                                                                                                                                                                                                                                                    })
                                                                                                                                                                                                                                                    // Start a sign in process for an unauthenticated user.
                                                                                                                                                                                                                                                    var provider = new firebase.auth.FacebookAuthProvider();
                                                                                                                                                                                                                                                    provider.addScope('user_birthday');
                                                                                                                                                                                                                                                    firebase.auth().signInWithRedirect(provider);

                                                                                                                                                                                                                                                    Example 2

                                                                                                                                                                                                                                                    // Sign in using a popup.
                                                                                                                                                                                                                                                    var provider = new firebase.auth.FacebookAuthProvider();
                                                                                                                                                                                                                                                    provider.addScope('user_birthday');
                                                                                                                                                                                                                                                    firebase.auth().signInWithPopup(provider).then(function(result) {
                                                                                                                                                                                                                                                    // This gives you a Facebook Access Token.
                                                                                                                                                                                                                                                    var token = result.credential.accessToken;
                                                                                                                                                                                                                                                    // The signed-in user info.
                                                                                                                                                                                                                                                    var user = result.user;
                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                  property FACEBOOK_SIGN_IN_METHOD

                                                                                                                                                                                                                                                  static FACEBOOK_SIGN_IN_METHOD: string;

                                                                                                                                                                                                                                                  property PROVIDER_ID

                                                                                                                                                                                                                                                  static PROVIDER_ID: string;

                                                                                                                                                                                                                                                    method credential

                                                                                                                                                                                                                                                    static credential: (token: string) => OAuthCredential;
                                                                                                                                                                                                                                                    • Parameter token

                                                                                                                                                                                                                                                      Facebook access token.

                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                      var cred = firebase.auth.FacebookAuthProvider.credential(
                                                                                                                                                                                                                                                      // `event` from the Facebook auth.authResponseChange callback.
                                                                                                                                                                                                                                                      event.authResponse.accessToken
                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                    class FacebookAuthProvider_Instance

                                                                                                                                                                                                                                                    class FacebookAuthProvider_Instance implements firebase.auth.AuthProvider {}

                                                                                                                                                                                                                                                    property providerId

                                                                                                                                                                                                                                                    providerId: string;

                                                                                                                                                                                                                                                      method addScope

                                                                                                                                                                                                                                                      addScope: (scope: string) => AuthProvider;
                                                                                                                                                                                                                                                      • Parameter scope

                                                                                                                                                                                                                                                        Facebook OAuth scope. The provider instance itself.

                                                                                                                                                                                                                                                      method setCustomParameters

                                                                                                                                                                                                                                                      setCustomParameters: (customOAuthParameters: Object) => AuthProvider;
                                                                                                                                                                                                                                                      • Sets the OAuth custom parameters to pass in a Facebook OAuth request for popup and redirect sign-in operations. Valid parameters include 'auth_type', 'display' and 'locale'. For a detailed list, check the documentation. Reserved required OAuth 2.0 parameters such as 'client_id', 'redirect_uri', 'scope', 'response_type' and 'state' are not allowed and will be ignored.

                                                                                                                                                                                                                                                        Parameter customOAuthParameters

                                                                                                                                                                                                                                                        The custom OAuth parameters to pass in the OAuth request. The provider instance itself.

                                                                                                                                                                                                                                                      class GithubAuthProvider

                                                                                                                                                                                                                                                      class GithubAuthProvider extends GithubAuthProvider_Instance {}
                                                                                                                                                                                                                                                      • GitHub auth provider.

                                                                                                                                                                                                                                                        GitHub requires an OAuth 2.0 redirect, so you can either handle the redirect directly, or use the signInWithPopup handler:

                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                        // Using a redirect.
                                                                                                                                                                                                                                                        firebase.auth().getRedirectResult().then(function(result) {
                                                                                                                                                                                                                                                        if (result.credential) {
                                                                                                                                                                                                                                                        // This gives you a GitHub Access Token.
                                                                                                                                                                                                                                                        var token = result.credential.accessToken;
                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                        var user = result.user;
                                                                                                                                                                                                                                                        }).catch(function(error) {
                                                                                                                                                                                                                                                        // Handle Errors here.
                                                                                                                                                                                                                                                        var errorCode = error.code;
                                                                                                                                                                                                                                                        var errorMessage = error.message;
                                                                                                                                                                                                                                                        // The email of the user's account used.
                                                                                                                                                                                                                                                        var email = error.email;
                                                                                                                                                                                                                                                        // The firebase.auth.AuthCredential type that was used.
                                                                                                                                                                                                                                                        var credential = error.credential;
                                                                                                                                                                                                                                                        if (errorCode === 'auth/account-exists-with-different-credential') {
                                                                                                                                                                                                                                                        alert('You have signed up with a different provider for that email.');
                                                                                                                                                                                                                                                        // Handle linking here if your app allows it.
                                                                                                                                                                                                                                                        } else {
                                                                                                                                                                                                                                                        console.error(error);
                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                        });
                                                                                                                                                                                                                                                        // Start a sign in process for an unauthenticated user.
                                                                                                                                                                                                                                                        var provider = new firebase.auth.GithubAuthProvider();
                                                                                                                                                                                                                                                        provider.addScope('repo');
                                                                                                                                                                                                                                                        firebase.auth().signInWithRedirect(provider);

                                                                                                                                                                                                                                                        Example 2

                                                                                                                                                                                                                                                        // With popup.
                                                                                                                                                                                                                                                        var provider = new firebase.auth.GithubAuthProvider();
                                                                                                                                                                                                                                                        provider.addScope('repo');
                                                                                                                                                                                                                                                        firebase.auth().signInWithPopup(provider).then(function(result) {
                                                                                                                                                                                                                                                        // This gives you a GitHub Access Token.
                                                                                                                                                                                                                                                        var token = result.credential.accessToken;
                                                                                                                                                                                                                                                        // The signed-in user info.
                                                                                                                                                                                                                                                        var user = result.user;
                                                                                                                                                                                                                                                        }).catch(function(error) {
                                                                                                                                                                                                                                                        // Handle Errors here.
                                                                                                                                                                                                                                                        var errorCode = error.code;
                                                                                                                                                                                                                                                        var errorMessage = error.message;
                                                                                                                                                                                                                                                        // The email of the user's account used.
                                                                                                                                                                                                                                                        var email = error.email;
                                                                                                                                                                                                                                                        // The firebase.auth.AuthCredential type that was used.
                                                                                                                                                                                                                                                        var credential = error.credential;
                                                                                                                                                                                                                                                        if (errorCode === 'auth/account-exists-with-different-credential') {
                                                                                                                                                                                                                                                        alert('You have signed up with a different provider for that email.');
                                                                                                                                                                                                                                                        // Handle linking here if your app allows it.
                                                                                                                                                                                                                                                        } else {
                                                                                                                                                                                                                                                        console.error(error);
                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                      property GITHUB_SIGN_IN_METHOD

                                                                                                                                                                                                                                                      static GITHUB_SIGN_IN_METHOD: string;

                                                                                                                                                                                                                                                      property PROVIDER_ID

                                                                                                                                                                                                                                                      static PROVIDER_ID: string;

                                                                                                                                                                                                                                                        method credential

                                                                                                                                                                                                                                                        static credential: (token: string) => OAuthCredential;
                                                                                                                                                                                                                                                        • Parameter token

                                                                                                                                                                                                                                                          GitHub access token. {!firebase.auth.OAuthCredential} The auth provider credential.

                                                                                                                                                                                                                                                          Example 1

                                                                                                                                                                                                                                                          var cred = firebase.auth.GithubAuthProvider.credential(
                                                                                                                                                                                                                                                          // `event` from the GitHub auth.authResponseChange callback.
                                                                                                                                                                                                                                                          event.authResponse.accessToken
                                                                                                                                                                                                                                                          );

                                                                                                                                                                                                                                                        class GithubAuthProvider_Instance

                                                                                                                                                                                                                                                        class GithubAuthProvider_Instance implements firebase.auth.AuthProvider {}

                                                                                                                                                                                                                                                        property providerId

                                                                                                                                                                                                                                                        providerId: string;

                                                                                                                                                                                                                                                          method addScope

                                                                                                                                                                                                                                                          addScope: (scope: string) => AuthProvider;
                                                                                                                                                                                                                                                          • Parameter scope

                                                                                                                                                                                                                                                            GitHub OAuth scope. The provider instance itself.

                                                                                                                                                                                                                                                          method setCustomParameters

                                                                                                                                                                                                                                                          setCustomParameters: (customOAuthParameters: Object) => AuthProvider;
                                                                                                                                                                                                                                                          • Sets the OAuth custom parameters to pass in a GitHub OAuth request for popup and redirect sign-in operations. Valid parameters include 'allow_signup'. For a detailed list, check the documentation. Reserved required OAuth 2.0 parameters such as 'client_id', 'redirect_uri', 'scope', 'response_type' and 'state' are not allowed and will be ignored.

                                                                                                                                                                                                                                                            Parameter customOAuthParameters

                                                                                                                                                                                                                                                            The custom OAuth parameters to pass in the OAuth request. The provider instance itself.

                                                                                                                                                                                                                                                          class GoogleAuthProvider

                                                                                                                                                                                                                                                          class GoogleAuthProvider extends GoogleAuthProvider_Instance {}
                                                                                                                                                                                                                                                          • Google auth provider.

                                                                                                                                                                                                                                                            Example 1

                                                                                                                                                                                                                                                            // Using a redirect.
                                                                                                                                                                                                                                                            firebase.auth().getRedirectResult().then(function(result) {
                                                                                                                                                                                                                                                            if (result.credential) {
                                                                                                                                                                                                                                                            // This gives you a Google Access Token.
                                                                                                                                                                                                                                                            var token = result.credential.accessToken;
                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                            var user = result.user;
                                                                                                                                                                                                                                                            });
                                                                                                                                                                                                                                                            // Start a sign in process for an unauthenticated user.
                                                                                                                                                                                                                                                            var provider = new firebase.auth.GoogleAuthProvider();
                                                                                                                                                                                                                                                            provider.addScope('profile');
                                                                                                                                                                                                                                                            provider.addScope('email');
                                                                                                                                                                                                                                                            firebase.auth().signInWithRedirect(provider);

                                                                                                                                                                                                                                                            Example 2

                                                                                                                                                                                                                                                            // Using a popup.
                                                                                                                                                                                                                                                            var provider = new firebase.auth.GoogleAuthProvider();
                                                                                                                                                                                                                                                            provider.addScope('profile');
                                                                                                                                                                                                                                                            provider.addScope('email');
                                                                                                                                                                                                                                                            firebase.auth().signInWithPopup(provider).then(function(result) {
                                                                                                                                                                                                                                                            // This gives you a Google Access Token.
                                                                                                                                                                                                                                                            var token = result.credential.accessToken;
                                                                                                                                                                                                                                                            // The signed-in user info.
                                                                                                                                                                                                                                                            var user = result.user;
                                                                                                                                                                                                                                                            });

                                                                                                                                                                                                                                                            See Also

                                                                                                                                                                                                                                                          property GOOGLE_SIGN_IN_METHOD

                                                                                                                                                                                                                                                          static GOOGLE_SIGN_IN_METHOD: string;

                                                                                                                                                                                                                                                          property PROVIDER_ID

                                                                                                                                                                                                                                                          static PROVIDER_ID: string;

                                                                                                                                                                                                                                                            method credential

                                                                                                                                                                                                                                                            static credential: (
                                                                                                                                                                                                                                                            idToken?: string | null,
                                                                                                                                                                                                                                                            accessToken?: string | null
                                                                                                                                                                                                                                                            ) => OAuthCredential;
                                                                                                                                                                                                                                                            • Creates a credential for Google. At least one of ID token and access token is required.

                                                                                                                                                                                                                                                              Parameter idToken

                                                                                                                                                                                                                                                              Google ID token.

                                                                                                                                                                                                                                                              Parameter accessToken

                                                                                                                                                                                                                                                              Google access token. The auth provider credential.

                                                                                                                                                                                                                                                              Example 1

                                                                                                                                                                                                                                                              // \`googleUser\` from the onsuccess Google Sign In callback.
                                                                                                                                                                                                                                                              var credential = firebase.auth.GoogleAuthProvider.credential(
                                                                                                                                                                                                                                                              googleUser.getAuthResponse().id_token);
                                                                                                                                                                                                                                                              firebase.auth().signInWithCredential(credential)

                                                                                                                                                                                                                                                            class GoogleAuthProvider_Instance

                                                                                                                                                                                                                                                            class GoogleAuthProvider_Instance implements firebase.auth.AuthProvider {}

                                                                                                                                                                                                                                                            property providerId

                                                                                                                                                                                                                                                            providerId: string;

                                                                                                                                                                                                                                                              method addScope

                                                                                                                                                                                                                                                              addScope: (scope: string) => AuthProvider;
                                                                                                                                                                                                                                                              • Parameter scope

                                                                                                                                                                                                                                                                Google OAuth scope. The provider instance itself.

                                                                                                                                                                                                                                                              method setCustomParameters

                                                                                                                                                                                                                                                              setCustomParameters: (customOAuthParameters: Object) => AuthProvider;
                                                                                                                                                                                                                                                              • Sets the OAuth custom parameters to pass in a Google OAuth request for popup and redirect sign-in operations. Valid parameters include 'hd', 'hl', 'include_granted_scopes', 'login_hint' and 'prompt'. For a detailed list, check the documentation. Reserved required OAuth 2.0 parameters such as 'client_id', 'redirect_uri', 'scope', 'response_type' and 'state' are not allowed and will be ignored.

                                                                                                                                                                                                                                                                Parameter customOAuthParameters

                                                                                                                                                                                                                                                                The custom OAuth parameters to pass in the OAuth request. The provider instance itself.

                                                                                                                                                                                                                                                              class MultiFactorAssertion

                                                                                                                                                                                                                                                              abstract class MultiFactorAssertion {}
                                                                                                                                                                                                                                                              • The base class for asserting ownership of a second factor. This is used to facilitate enrollment of a second factor on an existing user or sign-in of a user who already verified the first factor.

                                                                                                                                                                                                                                                              property factorId

                                                                                                                                                                                                                                                              factorId: string;
                                                                                                                                                                                                                                                              • The identifier of the second factor.

                                                                                                                                                                                                                                                              class MultiFactorResolver

                                                                                                                                                                                                                                                              class MultiFactorResolver {}
                                                                                                                                                                                                                                                              • The class used to facilitate recovery from firebase.auth.MultiFactorError when a user needs to provide a second factor to sign in.

                                                                                                                                                                                                                                                                Example 1

                                                                                                                                                                                                                                                                firebase.auth().signInWithEmailAndPassword()
                                                                                                                                                                                                                                                                .then(function(result) {
                                                                                                                                                                                                                                                                // User signed in. No 2nd factor challenge is needed.
                                                                                                                                                                                                                                                                })
                                                                                                                                                                                                                                                                .catch(function(error) {
                                                                                                                                                                                                                                                                if (error.code == 'auth/multi-factor-auth-required') {
                                                                                                                                                                                                                                                                var resolver = error.resolver;
                                                                                                                                                                                                                                                                // Show UI to let user select second factor.
                                                                                                                                                                                                                                                                var multiFactorHints = resolver.hints;
                                                                                                                                                                                                                                                                } else {
                                                                                                                                                                                                                                                                // Handle other errors.
                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                });
                                                                                                                                                                                                                                                                // The enrolled second factors that can be used to complete
                                                                                                                                                                                                                                                                // sign-in are returned in the `MultiFactorResolver.hints` list.
                                                                                                                                                                                                                                                                // UI needs to be presented to allow the user to select a second factor
                                                                                                                                                                                                                                                                // from that list.
                                                                                                                                                                                                                                                                var selectedHint = // ; selected from multiFactorHints
                                                                                                                                                                                                                                                                var phoneAuthProvider = new firebase.auth.PhoneAuthProvider();
                                                                                                                                                                                                                                                                var phoneInfoOptions = {
                                                                                                                                                                                                                                                                multiFactorHint: selectedHint,
                                                                                                                                                                                                                                                                session: resolver.session
                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                phoneAuthProvider.verifyPhoneNumber(
                                                                                                                                                                                                                                                                phoneInfoOptions,
                                                                                                                                                                                                                                                                appVerifier
                                                                                                                                                                                                                                                                ).then(function(verificationId) {
                                                                                                                                                                                                                                                                // store verificationID and show UI to let user enter verification code.
                                                                                                                                                                                                                                                                });
                                                                                                                                                                                                                                                                // UI to enter verification code and continue.
                                                                                                                                                                                                                                                                // Continue button click handler
                                                                                                                                                                                                                                                                var phoneAuthCredential =
                                                                                                                                                                                                                                                                firebase.auth.PhoneAuthProvider.credential(verificationId, verificationCode);
                                                                                                                                                                                                                                                                var multiFactorAssertion =
                                                                                                                                                                                                                                                                firebase.auth.PhoneMultiFactorGenerator.assertion(phoneAuthCredential);
                                                                                                                                                                                                                                                                resolver.resolveSignIn(multiFactorAssertion)
                                                                                                                                                                                                                                                                .then(function(userCredential) {
                                                                                                                                                                                                                                                                // User signed in.
                                                                                                                                                                                                                                                                });

                                                                                                                                                                                                                                                              property auth

                                                                                                                                                                                                                                                              auth: Auth;
                                                                                                                                                                                                                                                              • The Auth instance used to sign in with the first factor.

                                                                                                                                                                                                                                                              property hints

                                                                                                                                                                                                                                                              hints: MultiFactorInfo[];
                                                                                                                                                                                                                                                              • The list of hints for the second factors needed to complete the sign-in for the current session.

                                                                                                                                                                                                                                                              property session

                                                                                                                                                                                                                                                              session: MultiFactorSession;
                                                                                                                                                                                                                                                              • The session identifier for the current sign-in flow, which can be used to complete the second factor sign-in.

                                                                                                                                                                                                                                                              method resolveSignIn

                                                                                                                                                                                                                                                              resolveSignIn: (assertion: MultiFactorAssertion) => Promise<UserCredential>;
                                                                                                                                                                                                                                                              • A helper function to help users complete sign in with a second factor using an firebase.auth.MultiFactorAssertion confirming the user successfully completed the second factor challenge.

                                                                                                                                                                                                                                                                Error Codes auth/invalid-verification-code Thrown if the verification code is not valid. auth/missing-verification-code Thrown if the verification code is missing. auth/invalid-verification-id Thrown if the credential is a firebase.auth.PhoneAuthProvider.credential and the verification ID of the credential is not valid. auth/missing-verification-id Thrown if the verification ID is missing. auth/code-expired Thrown if the verification code has expired. auth/invalid-multi-factor-session Thrown if the request does not contain a valid proof of first factor successful sign-in. auth/missing-multi-factor-session Thrown if The request is missing proof of first factor successful sign-in.

                                                                                                                                                                                                                                                                Parameter assertion

                                                                                                                                                                                                                                                                The multi-factor assertion to resolve sign-in with. The promise that resolves with the user credential object.

                                                                                                                                                                                                                                                              class MultiFactorSession

                                                                                                                                                                                                                                                              class MultiFactorSession {}
                                                                                                                                                                                                                                                              • The multi-factor session object used for enrolling a second factor on a user or helping sign in an enrolled user with a second factor.

                                                                                                                                                                                                                                                              class OAuthCredential

                                                                                                                                                                                                                                                              class OAuthCredential extends AuthCredential {}
                                                                                                                                                                                                                                                              • Interface that represents the OAuth credentials returned by an OAuth provider. Implementations specify the details about each auth provider's credential requirements.

                                                                                                                                                                                                                                                              property accessToken

                                                                                                                                                                                                                                                              accessToken?: string;
                                                                                                                                                                                                                                                              • The OAuth access token associated with the credential if it belongs to an OAuth provider, such as facebook.com, twitter.com, etc.

                                                                                                                                                                                                                                                              property idToken

                                                                                                                                                                                                                                                              idToken?: string;
                                                                                                                                                                                                                                                              • The OAuth ID token associated with the credential if it belongs to an OIDC provider, such as google.com.

                                                                                                                                                                                                                                                              property secret

                                                                                                                                                                                                                                                              secret?: string;
                                                                                                                                                                                                                                                              • The OAuth access token secret associated with the credential if it belongs to an OAuth 1.0 provider, such as twitter.com.

                                                                                                                                                                                                                                                              class OAuthProvider

                                                                                                                                                                                                                                                              class OAuthProvider implements firebase.auth.AuthProvider {}
                                                                                                                                                                                                                                                              • Generic OAuth provider.

                                                                                                                                                                                                                                                                Parameter providerId

                                                                                                                                                                                                                                                                The associated provider ID, such as github.com.

                                                                                                                                                                                                                                                                Example 1

                                                                                                                                                                                                                                                                // Using a redirect.
                                                                                                                                                                                                                                                                firebase.auth().getRedirectResult().then(function(result) {
                                                                                                                                                                                                                                                                if (result.credential) {
                                                                                                                                                                                                                                                                // This gives you the OAuth Access Token for that provider.
                                                                                                                                                                                                                                                                var token = result.credential.accessToken;
                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                var user = result.user;
                                                                                                                                                                                                                                                                });
                                                                                                                                                                                                                                                                // Start a sign in process for an unauthenticated user.
                                                                                                                                                                                                                                                                var provider = new firebase.auth.OAuthProvider('google.com');
                                                                                                                                                                                                                                                                provider.addScope('profile');
                                                                                                                                                                                                                                                                provider.addScope('email');
                                                                                                                                                                                                                                                                firebase.auth().signInWithRedirect(provider);

                                                                                                                                                                                                                                                                Example 2

                                                                                                                                                                                                                                                                // Using a popup.
                                                                                                                                                                                                                                                                var provider = new firebase.auth.OAuthProvider('google.com');
                                                                                                                                                                                                                                                                provider.addScope('profile');
                                                                                                                                                                                                                                                                provider.addScope('email');
                                                                                                                                                                                                                                                                firebase.auth().signInWithPopup(provider).then(function(result) {
                                                                                                                                                                                                                                                                // This gives you the OAuth Access Token for that provider.
                                                                                                                                                                                                                                                                var token = result.credential.accessToken;
                                                                                                                                                                                                                                                                // The signed-in user info.
                                                                                                                                                                                                                                                                var user = result.user;
                                                                                                                                                                                                                                                                });

                                                                                                                                                                                                                                                                See Also

                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                              constructor(providerId: string);

                                                                                                                                                                                                                                                                property providerId

                                                                                                                                                                                                                                                                providerId: string;

                                                                                                                                                                                                                                                                  method addScope

                                                                                                                                                                                                                                                                  addScope: (scope: string) => AuthProvider;
                                                                                                                                                                                                                                                                  • Parameter scope

                                                                                                                                                                                                                                                                    Provider OAuth scope to add.

                                                                                                                                                                                                                                                                  method credential

                                                                                                                                                                                                                                                                  credential: (
                                                                                                                                                                                                                                                                  optionsOrIdToken: string | OAuthCredentialOptions,
                                                                                                                                                                                                                                                                  accessToken?: string
                                                                                                                                                                                                                                                                  ) => OAuthCredential;
                                                                                                                                                                                                                                                                  • Creates a Firebase credential from a generic OAuth provider's access token or ID token. The raw nonce is required when an ID token with a nonce field is provided. The SHA-256 hash of the raw nonce must match the nonce field in the ID token.

                                                                                                                                                                                                                                                                    Parameter optionsOrIdToken

                                                                                                                                                                                                                                                                    Either the options object containing the ID token, access token and raw nonce or the ID token string.

                                                                                                                                                                                                                                                                    Parameter accessToken

                                                                                                                                                                                                                                                                    The OAuth access token.

                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                    // `googleUser` from the onsuccess Google Sign In callback.
                                                                                                                                                                                                                                                                    // Initialize a generate OAuth provider with a `google.com` providerId.
                                                                                                                                                                                                                                                                    var provider = new firebase.auth.OAuthProvider('google.com');
                                                                                                                                                                                                                                                                    var credential = provider.credential({
                                                                                                                                                                                                                                                                    idToken: googleUser.getAuthResponse().id_token,
                                                                                                                                                                                                                                                                    });
                                                                                                                                                                                                                                                                    firebase.auth().signInWithCredential(credential)

                                                                                                                                                                                                                                                                  method setCustomParameters

                                                                                                                                                                                                                                                                  setCustomParameters: (customOAuthParameters: Object) => AuthProvider;
                                                                                                                                                                                                                                                                  • Sets the OAuth custom parameters to pass in an OAuth request for popup and redirect sign-in operations. For a detailed list, check the reserved required OAuth 2.0 parameters such as client_id, redirect_uri, scope, response_type and state are not allowed and will be ignored.

                                                                                                                                                                                                                                                                    Parameter customOAuthParameters

                                                                                                                                                                                                                                                                    The custom OAuth parameters to pass in the OAuth request.

                                                                                                                                                                                                                                                                  class PhoneAuthCredential

                                                                                                                                                                                                                                                                  class PhoneAuthCredential extends AuthCredential {}

                                                                                                                                                                                                                                                                  class PhoneAuthProvider

                                                                                                                                                                                                                                                                  class PhoneAuthProvider extends PhoneAuthProvider_Instance {}
                                                                                                                                                                                                                                                                  • Phone number auth provider.

                                                                                                                                                                                                                                                                    Parameter auth

                                                                                                                                                                                                                                                                    The Firebase Auth instance in which sign-ins should occur. Uses the default Auth instance if unspecified.

                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                    // 'recaptcha-container' is the ID of an element in the DOM.
                                                                                                                                                                                                                                                                    var applicationVerifier = new firebase.auth.RecaptchaVerifier(
                                                                                                                                                                                                                                                                    'recaptcha-container');
                                                                                                                                                                                                                                                                    var provider = new firebase.auth.PhoneAuthProvider();
                                                                                                                                                                                                                                                                    provider.verifyPhoneNumber('+16505550101', applicationVerifier)
                                                                                                                                                                                                                                                                    .then(function(verificationId) {
                                                                                                                                                                                                                                                                    var verificationCode = window.prompt('Please enter the verification ' +
                                                                                                                                                                                                                                                                    'code that was sent to your mobile device.');
                                                                                                                                                                                                                                                                    return firebase.auth.PhoneAuthProvider.credential(verificationId,
                                                                                                                                                                                                                                                                    verificationCode);
                                                                                                                                                                                                                                                                    })
                                                                                                                                                                                                                                                                    .then(function(phoneCredential) {
                                                                                                                                                                                                                                                                    return firebase.auth().signInWithCredential(phoneCredential);
                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                  property PHONE_SIGN_IN_METHOD

                                                                                                                                                                                                                                                                  static PHONE_SIGN_IN_METHOD: string;

                                                                                                                                                                                                                                                                  property PROVIDER_ID

                                                                                                                                                                                                                                                                  static PROVIDER_ID: string;

                                                                                                                                                                                                                                                                    method credential

                                                                                                                                                                                                                                                                    static credential: (
                                                                                                                                                                                                                                                                    verificationId: string,
                                                                                                                                                                                                                                                                    verificationCode: string
                                                                                                                                                                                                                                                                    ) => AuthCredential;
                                                                                                                                                                                                                                                                    • Creates a phone auth credential, given the verification ID from firebase.auth.PhoneAuthProvider.verifyPhoneNumber and the code that was sent to the user's mobile device.

                                                                                                                                                                                                                                                                      Error Codes auth/missing-verification-code Thrown if the verification code is missing. auth/missing-verification-id Thrown if the verification ID is missing.

                                                                                                                                                                                                                                                                      Parameter verificationId

                                                                                                                                                                                                                                                                      The verification ID returned from firebase.auth.PhoneAuthProvider.verifyPhoneNumber.

                                                                                                                                                                                                                                                                      Parameter verificationCode

                                                                                                                                                                                                                                                                      The verification code sent to the user's mobile device. The auth provider credential.

                                                                                                                                                                                                                                                                    class PhoneAuthProvider_Instance

                                                                                                                                                                                                                                                                    class PhoneAuthProvider_Instance implements firebase.auth.AuthProvider {}

                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                    constructor(auth?: Auth);

                                                                                                                                                                                                                                                                      property providerId

                                                                                                                                                                                                                                                                      providerId: string;

                                                                                                                                                                                                                                                                        method verifyPhoneNumber

                                                                                                                                                                                                                                                                        verifyPhoneNumber: (
                                                                                                                                                                                                                                                                        phoneInfoOptions: string | PhoneInfoOptions,
                                                                                                                                                                                                                                                                        applicationVerifier: ApplicationVerifier
                                                                                                                                                                                                                                                                        ) => Promise<string>;
                                                                                                                                                                                                                                                                        • Starts a phone number authentication flow by sending a verification code to the given phone number. Returns an ID that can be passed to firebase.auth.PhoneAuthProvider.credential to identify this flow.

                                                                                                                                                                                                                                                                          For abuse prevention, this method also requires a firebase.auth.ApplicationVerifier. The Firebase Auth SDK includes a reCAPTCHA-based implementation, firebase.auth.RecaptchaVerifier.

                                                                                                                                                                                                                                                                          Error Codes auth/captcha-check-failed Thrown if the reCAPTCHA response token was invalid, expired, or if this method was called from a non-whitelisted domain. auth/invalid-phone-number Thrown if the phone number has an invalid format. auth/missing-phone-number Thrown if the phone number is missing. auth/quota-exceeded Thrown if the SMS quota for the Firebase project has been exceeded. auth/user-disabled Thrown if the user corresponding to the given phone number has been disabled. auth/maximum-second-factor-count-exceeded Thrown if The maximum allowed number of second factors on a user has been exceeded. auth/second-factor-already-in-use Thrown if the second factor is already enrolled on this account. auth/unsupported-first-factor Thrown if the first factor being used to sign in is not supported. auth/unverified-email Thrown if the email of the account is not verified.

                                                                                                                                                                                                                                                                          Parameter phoneInfoOptions

                                                                                                                                                                                                                                                                          The user's firebase.auth.PhoneInfoOptions. The phone number should be in E.164 format (e.g. +16505550101).

                                                                                                                                                                                                                                                                          Parameter applicationVerifier

                                                                                                                                                                                                                                                                          A Promise for the verification ID.

                                                                                                                                                                                                                                                                        class PhoneMultiFactorAssertion

                                                                                                                                                                                                                                                                        class PhoneMultiFactorAssertion extends firebase.auth.MultiFactorAssertion {}
                                                                                                                                                                                                                                                                        • The class for asserting ownership of a phone second factor.

                                                                                                                                                                                                                                                                        class PhoneMultiFactorGenerator

                                                                                                                                                                                                                                                                        class PhoneMultiFactorGenerator {}

                                                                                                                                                                                                                                                                        property FACTOR_ID

                                                                                                                                                                                                                                                                        static FACTOR_ID: string;
                                                                                                                                                                                                                                                                        • The identifier of the phone second factor: phone.

                                                                                                                                                                                                                                                                        method assertion

                                                                                                                                                                                                                                                                        static assertion: (
                                                                                                                                                                                                                                                                        phoneAuthCredential: PhoneAuthCredential
                                                                                                                                                                                                                                                                        ) => PhoneMultiFactorAssertion;

                                                                                                                                                                                                                                                                        class RecaptchaVerifier

                                                                                                                                                                                                                                                                        class RecaptchaVerifier extends RecaptchaVerifier_Instance {}
                                                                                                                                                                                                                                                                        • An -based application verifier.

                                                                                                                                                                                                                                                                          This class does not work in a Node.js environment.

                                                                                                                                                                                                                                                                          Parameter container

                                                                                                                                                                                                                                                                          The reCAPTCHA container parameter. This has different meaning depending on whether the reCAPTCHA is hidden or visible. For a visible reCAPTCHA the container must be empty. If a string is used, it has to correspond to an element ID. The corresponding element must also must be in the DOM at the time of initialization.

                                                                                                                                                                                                                                                                          Parameter parameters

                                                                                                                                                                                                                                                                          The optional reCAPTCHA parameters. Check the reCAPTCHA docs for a comprehensive list. All parameters are accepted except for the sitekey. Firebase Auth backend provisions a reCAPTCHA for each project and will configure this upon rendering. For an invisible reCAPTCHA, a size key must have the value 'invisible'.

                                                                                                                                                                                                                                                                          Parameter app

                                                                                                                                                                                                                                                                          The corresponding Firebase app. If none is provided, the default Firebase App instance is used. A Firebase App instance must be initialized with an API key, otherwise an error will be thrown.

                                                                                                                                                                                                                                                                        class RecaptchaVerifier_Instance

                                                                                                                                                                                                                                                                        class RecaptchaVerifier_Instance implements firebase.auth.ApplicationVerifier {}

                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                        constructor(container: any, parameters?: Object, app?: app.App);

                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                          type: string;
                                                                                                                                                                                                                                                                          • The application verifier type. For a reCAPTCHA verifier, this is 'recaptcha'.

                                                                                                                                                                                                                                                                          method clear

                                                                                                                                                                                                                                                                          clear: () => void;
                                                                                                                                                                                                                                                                          • Clears the reCAPTCHA widget from the page and destroys the current instance.

                                                                                                                                                                                                                                                                          method render

                                                                                                                                                                                                                                                                          render: () => Promise<number>;
                                                                                                                                                                                                                                                                          • Renders the reCAPTCHA widget on the page. A Promise that resolves with the reCAPTCHA widget ID.

                                                                                                                                                                                                                                                                          method verify

                                                                                                                                                                                                                                                                          verify: () => Promise<string>;
                                                                                                                                                                                                                                                                          • Waits for the user to solve the reCAPTCHA and resolves with the reCAPTCHA token. A Promise for the reCAPTCHA token.

                                                                                                                                                                                                                                                                          class SAMLAuthProvider

                                                                                                                                                                                                                                                                          class SAMLAuthProvider implements firebase.auth.AuthProvider {}

                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                            constructor(providerId: string);

                                                                                                                                                                                                                                                                              property providerId

                                                                                                                                                                                                                                                                              providerId: string;

                                                                                                                                                                                                                                                                                class TwitterAuthProvider

                                                                                                                                                                                                                                                                                class TwitterAuthProvider extends TwitterAuthProvider_Instance {}
                                                                                                                                                                                                                                                                                • Twitter auth provider.

                                                                                                                                                                                                                                                                                  Example 1

                                                                                                                                                                                                                                                                                  // Using a redirect.
                                                                                                                                                                                                                                                                                  firebase.auth().getRedirectResult().then(function(result) {
                                                                                                                                                                                                                                                                                  if (result.credential) {
                                                                                                                                                                                                                                                                                  // For accessing the Twitter API.
                                                                                                                                                                                                                                                                                  var token = result.credential.accessToken;
                                                                                                                                                                                                                                                                                  var secret = result.credential.secret;
                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                  var user = result.user;
                                                                                                                                                                                                                                                                                  });
                                                                                                                                                                                                                                                                                  // Start a sign in process for an unauthenticated user.
                                                                                                                                                                                                                                                                                  var provider = new firebase.auth.TwitterAuthProvider();
                                                                                                                                                                                                                                                                                  firebase.auth().signInWithRedirect(provider);

                                                                                                                                                                                                                                                                                  Example 2

                                                                                                                                                                                                                                                                                  // Using a popup.
                                                                                                                                                                                                                                                                                  var provider = new firebase.auth.TwitterAuthProvider();
                                                                                                                                                                                                                                                                                  firebase.auth().signInWithPopup(provider).then(function(result) {
                                                                                                                                                                                                                                                                                  // For accessing the Twitter API.
                                                                                                                                                                                                                                                                                  var token = result.credential.accessToken;
                                                                                                                                                                                                                                                                                  var secret = result.credential.secret;
                                                                                                                                                                                                                                                                                  // The signed-in user info.
                                                                                                                                                                                                                                                                                  var user = result.user;
                                                                                                                                                                                                                                                                                  });

                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                property PROVIDER_ID

                                                                                                                                                                                                                                                                                static PROVIDER_ID: string;

                                                                                                                                                                                                                                                                                  property TWITTER_SIGN_IN_METHOD

                                                                                                                                                                                                                                                                                  static TWITTER_SIGN_IN_METHOD: string;

                                                                                                                                                                                                                                                                                  method credential

                                                                                                                                                                                                                                                                                  static credential: (token: string, secret: string) => OAuthCredential;
                                                                                                                                                                                                                                                                                  • Parameter token

                                                                                                                                                                                                                                                                                    Twitter access token.

                                                                                                                                                                                                                                                                                    Parameter secret

                                                                                                                                                                                                                                                                                    Twitter secret. The auth provider credential.

                                                                                                                                                                                                                                                                                  class TwitterAuthProvider_Instance

                                                                                                                                                                                                                                                                                  class TwitterAuthProvider_Instance implements firebase.auth.AuthProvider {}

                                                                                                                                                                                                                                                                                  property providerId

                                                                                                                                                                                                                                                                                  providerId: string;

                                                                                                                                                                                                                                                                                    method setCustomParameters

                                                                                                                                                                                                                                                                                    setCustomParameters: (customOAuthParameters: Object) => AuthProvider;
                                                                                                                                                                                                                                                                                    • Sets the OAuth custom parameters to pass in a Twitter OAuth request for popup and redirect sign-in operations. Valid parameters include 'lang'. Reserved required OAuth 1.0 parameters such as 'oauth_consumer_key', 'oauth_token', 'oauth_signature', etc are not allowed and will be ignored.

                                                                                                                                                                                                                                                                                      Parameter customOAuthParameters

                                                                                                                                                                                                                                                                                      The custom OAuth parameters to pass in the OAuth request. The provider instance itself.

                                                                                                                                                                                                                                                                                    interface ActionCodeInfo

                                                                                                                                                                                                                                                                                    interface ActionCodeInfo {}

                                                                                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                                                                                    data: {
                                                                                                                                                                                                                                                                                    email?: string | null;
                                                                                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                                                                                    * @deprecated
                                                                                                                                                                                                                                                                                    * This field is deprecated in favor of previousEmail.
                                                                                                                                                                                                                                                                                    */
                                                                                                                                                                                                                                                                                    fromEmail?: string | null;
                                                                                                                                                                                                                                                                                    multiFactorInfo?: firebase.auth.MultiFactorInfo | null;
                                                                                                                                                                                                                                                                                    previousEmail?: string | null;
                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                    • The data associated with the action code.

                                                                                                                                                                                                                                                                                      For the PASSWORD_RESET, VERIFY_EMAIL, and RECOVER_EMAIL actions, this object contains an email field with the address the email was sent to.

                                                                                                                                                                                                                                                                                      For the RECOVER_EMAIL action, which allows a user to undo an email address change, this object also contains a previousEmail field with the user account's current email address. After the action completes, the user's email address will revert to the value in the email field from the value in previousEmail field.

                                                                                                                                                                                                                                                                                      For the VERIFY_AND_CHANGE_EMAIL action, which allows a user to verify the email before updating it, this object contains a previousEmail field with the user account's email address before updating. After the action completes, the user's email address will be updated to the value in the email field from the value in previousEmail field.

                                                                                                                                                                                                                                                                                      For the REVERT_SECOND_FACTOR_ADDITION action, which allows a user to unenroll a newly added second factor, this object contains a multiFactorInfo field with the information about the second factor. For phone second factor, the multiFactorInfo is a firebase.auth.PhoneMultiFactorInfo object, which contains the phone number.

                                                                                                                                                                                                                                                                                    property operation

                                                                                                                                                                                                                                                                                    operation: string;

                                                                                                                                                                                                                                                                                    interface ApplicationVerifier

                                                                                                                                                                                                                                                                                    interface ApplicationVerifier {}

                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                    type: string;
                                                                                                                                                                                                                                                                                    • Identifies the type of application verifier (e.g. "recaptcha").

                                                                                                                                                                                                                                                                                    method verify

                                                                                                                                                                                                                                                                                    verify: () => Promise<string>;
                                                                                                                                                                                                                                                                                    • Executes the verification process. A Promise for a token that can be used to assert the validity of a request.

                                                                                                                                                                                                                                                                                    interface Auth

                                                                                                                                                                                                                                                                                    interface Auth {}
                                                                                                                                                                                                                                                                                    • The Firebase Auth service interface.

                                                                                                                                                                                                                                                                                      Do not call this constructor directly. Instead, use .

                                                                                                                                                                                                                                                                                      See for a full guide on how to use the Firebase Auth service.

                                                                                                                                                                                                                                                                                    property app

                                                                                                                                                                                                                                                                                    app: firebase.app.App;
                                                                                                                                                                                                                                                                                    • The associated with the Auth service instance.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      var app = auth.app;

                                                                                                                                                                                                                                                                                    property config

                                                                                                                                                                                                                                                                                    readonly config: Config;
                                                                                                                                                                                                                                                                                    • The config used to initialize this instance.

                                                                                                                                                                                                                                                                                    property currentUser

                                                                                                                                                                                                                                                                                    currentUser: firebase.User | null;
                                                                                                                                                                                                                                                                                    • The currently signed-in user (or null).

                                                                                                                                                                                                                                                                                    property emulatorConfig

                                                                                                                                                                                                                                                                                    readonly emulatorConfig: EmulatorConfig | null;
                                                                                                                                                                                                                                                                                    • The current emulator configuration (or null).

                                                                                                                                                                                                                                                                                    property languageCode

                                                                                                                                                                                                                                                                                    languageCode: string | null;
                                                                                                                                                                                                                                                                                    • The current Auth instance's language code. This is a readable/writable property. When set to null, the default Firebase Console language setting is applied. The language code will propagate to email action templates (password reset, email verification and email change revocation), SMS templates for phone authentication, reCAPTCHA verifier and OAuth popup/redirect operations provided the specified providers support localization with the language code specified.

                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                    readonly name: string;
                                                                                                                                                                                                                                                                                    • The name of the app associated with the Auth service instance.

                                                                                                                                                                                                                                                                                    property settings

                                                                                                                                                                                                                                                                                    settings: firebase.auth.AuthSettings;
                                                                                                                                                                                                                                                                                    • The current Auth instance's settings. This is used to edit/read configuration related options like app verification mode for phone authentication.

                                                                                                                                                                                                                                                                                    property tenantId

                                                                                                                                                                                                                                                                                    tenantId: string | null;
                                                                                                                                                                                                                                                                                    • The current Auth instance's tenant ID. This is a readable/writable property. When you set the tenant ID of an Auth instance, all future sign-in/sign-up operations will pass this tenant ID and sign in or sign up users to the specified tenant project. When set to null, users are signed in to the parent project. By default, this is set to null.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      // Set the tenant ID on Auth instance.
                                                                                                                                                                                                                                                                                      firebase.auth().tenantId =TENANT_PROJECT_ID;
                                                                                                                                                                                                                                                                                      // All future sign-in request now include tenant ID.
                                                                                                                                                                                                                                                                                      firebase.auth().signInWithEmailAndPassword(email, password)
                                                                                                                                                                                                                                                                                      .then(function(result) {
                                                                                                                                                                                                                                                                                      // result.user.tenantId should be ‘TENANT_PROJECT_ID’.
                                                                                                                                                                                                                                                                                      }).catch(function(error) {
                                                                                                                                                                                                                                                                                      // Handle error.
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                    method applyActionCode

                                                                                                                                                                                                                                                                                    applyActionCode: (code: string) => Promise<void>;
                                                                                                                                                                                                                                                                                    • Applies a verification code sent to the user by email or other out-of-band mechanism.

                                                                                                                                                                                                                                                                                      Error Codes auth/expired-action-code Thrown if the action code has expired. auth/invalid-action-code Thrown if the action code is invalid. This can happen if the code is malformed or has already been used. auth/user-disabled Thrown if the user corresponding to the given action code has been disabled. auth/user-not-found Thrown if there is no user corresponding to the action code. This may have happened if the user was deleted between when the action code was issued and when this method was called.

                                                                                                                                                                                                                                                                                      Parameter code

                                                                                                                                                                                                                                                                                      A verification code sent to the user.

                                                                                                                                                                                                                                                                                    method checkActionCode

                                                                                                                                                                                                                                                                                    checkActionCode: (code: string) => Promise<ActionCodeInfo>;
                                                                                                                                                                                                                                                                                    • Checks a verification code sent to the user by email or other out-of-band mechanism.

                                                                                                                                                                                                                                                                                      Returns metadata about the code.

                                                                                                                                                                                                                                                                                      Error Codes auth/expired-action-code Thrown if the action code has expired. auth/invalid-action-code Thrown if the action code is invalid. This can happen if the code is malformed or has already been used. auth/user-disabled Thrown if the user corresponding to the given action code has been disabled. auth/user-not-found Thrown if there is no user corresponding to the action code. This may have happened if the user was deleted between when the action code was issued and when this method was called.

                                                                                                                                                                                                                                                                                      Parameter code

                                                                                                                                                                                                                                                                                      A verification code sent to the user.

                                                                                                                                                                                                                                                                                    method confirmPasswordReset

                                                                                                                                                                                                                                                                                    confirmPasswordReset: (code: string, newPassword: string) => Promise<void>;
                                                                                                                                                                                                                                                                                    • Completes the password reset process, given a confirmation code and new password.

                                                                                                                                                                                                                                                                                      Error Codes auth/expired-action-code Thrown if the password reset code has expired. auth/invalid-action-code Thrown if the password reset code is invalid. This can happen if the code is malformed or has already been used. auth/user-disabled Thrown if the user corresponding to the given password reset code has been disabled. auth/user-not-found Thrown if there is no user corresponding to the password reset code. This may have happened if the user was deleted between when the code was issued and when this method was called. auth/weak-password Thrown if the new password is not strong enough.

                                                                                                                                                                                                                                                                                      Parameter code

                                                                                                                                                                                                                                                                                      The confirmation code send via email to the user.

                                                                                                                                                                                                                                                                                      Parameter newPassword

                                                                                                                                                                                                                                                                                      The new password.

                                                                                                                                                                                                                                                                                    method createUserWithEmailAndPassword

                                                                                                                                                                                                                                                                                    createUserWithEmailAndPassword: (
                                                                                                                                                                                                                                                                                    email: string,
                                                                                                                                                                                                                                                                                    password: string
                                                                                                                                                                                                                                                                                    ) => Promise<UserCredential>;
                                                                                                                                                                                                                                                                                    • Creates a new user account associated with the specified email address and password.

                                                                                                                                                                                                                                                                                      On successful creation of the user account, this user will also be signed in to your application.

                                                                                                                                                                                                                                                                                      User account creation can fail if the account already exists or the password is invalid.

                                                                                                                                                                                                                                                                                      Note: The email address acts as a unique identifier for the user and enables an email-based password reset. This function will create a new user account and set the initial user password.

                                                                                                                                                                                                                                                                                      Error Codes auth/email-already-in-use Thrown if there already exists an account with the given email address. auth/invalid-email Thrown if the email address is not valid. auth/operation-not-allowed Thrown if email/password accounts are not enabled. Enable email/password accounts in the Firebase Console, under the Auth tab. auth/weak-password Thrown if the password is not strong enough.

                                                                                                                                                                                                                                                                                      Parameter email

                                                                                                                                                                                                                                                                                      The user's email address.

                                                                                                                                                                                                                                                                                      Parameter password

                                                                                                                                                                                                                                                                                      The user's chosen password.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      firebase.auth().createUserWithEmailAndPassword(email, password)
                                                                                                                                                                                                                                                                                      .catch(function(error) {
                                                                                                                                                                                                                                                                                      // Handle Errors here.
                                                                                                                                                                                                                                                                                      var errorCode = error.code;
                                                                                                                                                                                                                                                                                      var errorMessage = error.message;
                                                                                                                                                                                                                                                                                      if (errorCode == 'auth/weak-password') {
                                                                                                                                                                                                                                                                                      alert('The password is too weak.');
                                                                                                                                                                                                                                                                                      } else {
                                                                                                                                                                                                                                                                                      alert(errorMessage);
                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                      console.log(error);
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                    method fetchSignInMethodsForEmail

                                                                                                                                                                                                                                                                                    fetchSignInMethodsForEmail: (email: string) => Promise<Array<string>>;
                                                                                                                                                                                                                                                                                    • Gets the list of possible sign in methods for the given email address. This is useful to differentiate methods of sign-in for the same provider, eg. EmailAuthProvider which has 2 methods of sign-in, email/password and email/link.

                                                                                                                                                                                                                                                                                      Error Codes auth/invalid-email Thrown if the email address is not valid.

                                                                                                                                                                                                                                                                                    method getRedirectResult

                                                                                                                                                                                                                                                                                    getRedirectResult: () => Promise<UserCredential>;
                                                                                                                                                                                                                                                                                    • Returns a UserCredential from the redirect-based sign-in flow.

                                                                                                                                                                                                                                                                                      If sign-in succeeded, returns the signed in user. If sign-in was unsuccessful, fails with an error. If no redirect operation was called, returns null.

                                                                                                                                                                                                                                                                                      Error Codes auth/account-exists-with-different-credential Thrown if there already exists an account with the email address asserted by the credential. Resolve this by calling firebase.auth.Auth.fetchSignInMethodsForEmail with the error.email and then asking the user to sign in using one of the returned providers. Once the user is signed in, the original credential retrieved from the error.credential can be linked to the user with firebase.User.linkWithCredential to prevent the user from signing in again to the original provider via popup or redirect. If you are using redirects for sign in, save the credential in session storage and then retrieve on redirect and repopulate the credential using for example firebase.auth.GoogleAuthProvider.credential depending on the credential provider id and complete the link. auth/auth-domain-config-required Thrown if authDomain configuration is not provided when calling firebase.initializeApp(). Check Firebase Console for instructions on determining and passing that field. auth/credential-already-in-use Thrown if the account corresponding to the credential already exists among your users, or is already linked to a Firebase User. For example, this error could be thrown if you are upgrading an anonymous user to a Google user by linking a Google credential to it and the Google credential used is already associated with an existing Firebase Google user. An error.email and error.credential (firebase.auth.AuthCredential) fields are also provided. You can recover from this error by signing in with that credential directly via firebase.auth.Auth.signInWithCredential. auth/email-already-in-use Thrown if the email corresponding to the credential already exists among your users. When thrown while linking a credential to an existing user, an error.email and error.credential (firebase.auth.AuthCredential) fields are also provided. You have to link the credential to the existing user with that email if you wish to continue signing in with that credential. To do so, call firebase.auth.Auth.fetchSignInMethodsForEmail, sign in to error.email via one of the providers returned and then firebase.User.linkWithCredential the original credential to that newly signed in user. auth/operation-not-allowed Thrown if the type of account corresponding to the credential is not enabled. Enable the account type in the Firebase Console, under the Auth tab. auth/operation-not-supported-in-this-environment Thrown if this operation is not supported in the environment your application is running on. "location.protocol" must be http or https. auth/timeout Thrown typically if the app domain is not authorized for OAuth operations for your Firebase project. Edit the list of authorized domains from the Firebase console.

                                                                                                                                                                                                                                                                                      This method does not work in a Node.js environment.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      // First, we perform the signInWithRedirect.
                                                                                                                                                                                                                                                                                      // Creates the provider object.
                                                                                                                                                                                                                                                                                      var provider = new firebase.auth.FacebookAuthProvider();
                                                                                                                                                                                                                                                                                      // You can add additional scopes to the provider:
                                                                                                                                                                                                                                                                                      provider.addScope('email');
                                                                                                                                                                                                                                                                                      provider.addScope('user_friends');
                                                                                                                                                                                                                                                                                      // Sign in with redirect:
                                                                                                                                                                                                                                                                                      auth.signInWithRedirect(provider)
                                                                                                                                                                                                                                                                                      ////////////////////////////////////////////////////////////
                                                                                                                                                                                                                                                                                      // The user is redirected to the provider's sign in flow...
                                                                                                                                                                                                                                                                                      ////////////////////////////////////////////////////////////
                                                                                                                                                                                                                                                                                      // Then redirected back to the app, where we check the redirect result:
                                                                                                                                                                                                                                                                                      auth.getRedirectResult().then(function(result) {
                                                                                                                                                                                                                                                                                      // The firebase.User instance:
                                                                                                                                                                                                                                                                                      var user = result.user;
                                                                                                                                                                                                                                                                                      // The Facebook firebase.auth.AuthCredential containing the Facebook
                                                                                                                                                                                                                                                                                      // access token:
                                                                                                                                                                                                                                                                                      var credential = result.credential;
                                                                                                                                                                                                                                                                                      // As this API can be used for sign-in, linking and reauthentication,
                                                                                                                                                                                                                                                                                      // check the operationType to determine what triggered this redirect
                                                                                                                                                                                                                                                                                      // operation.
                                                                                                                                                                                                                                                                                      var operationType = result.operationType;
                                                                                                                                                                                                                                                                                      }, function(error) {
                                                                                                                                                                                                                                                                                      // The provider's account email, can be used in case of
                                                                                                                                                                                                                                                                                      // auth/account-exists-with-different-credential to fetch the providers
                                                                                                                                                                                                                                                                                      // linked to the email:
                                                                                                                                                                                                                                                                                      var email = error.email;
                                                                                                                                                                                                                                                                                      // The provider's credential:
                                                                                                                                                                                                                                                                                      var credential = error.credential;
                                                                                                                                                                                                                                                                                      // In case of auth/account-exists-with-different-credential error,
                                                                                                                                                                                                                                                                                      // you can fetch the providers using this:
                                                                                                                                                                                                                                                                                      if (error.code === 'auth/account-exists-with-different-credential') {
                                                                                                                                                                                                                                                                                      auth.fetchSignInMethodsForEmail(email).then(function(providers) {
                                                                                                                                                                                                                                                                                      // The returned 'providers' is a list of the available providers
                                                                                                                                                                                                                                                                                      // linked to the email address. Please refer to the guide for a more
                                                                                                                                                                                                                                                                                      // complete explanation on how to recover from this error.
                                                                                                                                                                                                                                                                                      });
                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                      });
                                                                                                                                                                                                                                                                                    isSignInWithEmailLink: (emailLink: string) => boolean;
                                                                                                                                                                                                                                                                                    • Checks if an incoming link is a sign-in with email link.

                                                                                                                                                                                                                                                                                    method onAuthStateChanged

                                                                                                                                                                                                                                                                                    onAuthStateChanged: (
                                                                                                                                                                                                                                                                                    nextOrObserver:
                                                                                                                                                                                                                                                                                    | Observer<any, globalThis.Error>
                                                                                                                                                                                                                                                                                    | ((a: firebase.User | null) => any),
                                                                                                                                                                                                                                                                                    error?: (a: Error) => any,
                                                                                                                                                                                                                                                                                    completed?: firebase.Unsubscribe
                                                                                                                                                                                                                                                                                    ) => firebase.Unsubscribe;
                                                                                                                                                                                                                                                                                    • Adds an observer for changes to the user's sign-in state.

                                                                                                                                                                                                                                                                                      Prior to 4.0.0, this triggered the observer when users were signed in, signed out, or when the user's ID token changed in situations such as token expiry or password change. After 4.0.0, the observer is only triggered on sign-in or sign-out.

                                                                                                                                                                                                                                                                                      To keep the old behavior, see firebase.auth.Auth.onIdTokenChanged.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      firebase.auth().onAuthStateChanged(function(user) {
                                                                                                                                                                                                                                                                                      if (user) {
                                                                                                                                                                                                                                                                                      // User is signed in.
                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                    method onIdTokenChanged

                                                                                                                                                                                                                                                                                    onIdTokenChanged: (
                                                                                                                                                                                                                                                                                    nextOrObserver:
                                                                                                                                                                                                                                                                                    | Observer<any, globalThis.Error>
                                                                                                                                                                                                                                                                                    | ((a: firebase.User | null) => any),
                                                                                                                                                                                                                                                                                    error?: (a: Error) => any,
                                                                                                                                                                                                                                                                                    completed?: firebase.Unsubscribe
                                                                                                                                                                                                                                                                                    ) => firebase.Unsubscribe;
                                                                                                                                                                                                                                                                                    • Adds an observer for changes to the signed-in user's ID token, which includes sign-in, sign-out, and token refresh events. This method has the same behavior as firebase.auth.Auth.onAuthStateChanged had prior to 4.0.0.

                                                                                                                                                                                                                                                                                      Parameter nextOrObserver

                                                                                                                                                                                                                                                                                      An observer object or a function triggered on change.

                                                                                                                                                                                                                                                                                      Parameter error

                                                                                                                                                                                                                                                                                      Optional A function triggered on auth error.

                                                                                                                                                                                                                                                                                      Parameter completed

                                                                                                                                                                                                                                                                                      Optional A function triggered when the observer is removed.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      firebase.auth().onIdTokenChanged(function(user) {
                                                                                                                                                                                                                                                                                      if (user) {
                                                                                                                                                                                                                                                                                      // User is signed in or token was refreshed.
                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                    method sendPasswordResetEmail

                                                                                                                                                                                                                                                                                    sendPasswordResetEmail: (
                                                                                                                                                                                                                                                                                    email: string,
                                                                                                                                                                                                                                                                                    actionCodeSettings?: ActionCodeSettings
                                                                                                                                                                                                                                                                                    ) => Promise<void>;
                                                                                                                                                                                                                                                                                    • Sends a password reset email to the given email address.

                                                                                                                                                                                                                                                                                      To complete the password reset, call firebase.auth.Auth.confirmPasswordReset with the code supplied in the email sent to the user, along with the new password specified by the user.

                                                                                                                                                                                                                                                                                      Error Codes auth/invalid-email Thrown if the email address is not valid. auth/missing-android-pkg-name An Android package name must be provided if the Android app is required to be installed. auth/missing-continue-uri A continue URL must be provided in the request. auth/missing-ios-bundle-id An iOS Bundle ID must be provided if an App Store ID is provided. auth/invalid-continue-uri The continue URL provided in the request is invalid. auth/unauthorized-continue-uri The domain of the continue URL is not whitelisted. Whitelist the domain in the Firebase console. auth/user-not-found Thrown if there is no user corresponding to the email address.

                                                                                                                                                                                                                                                                                      Parameter email

                                                                                                                                                                                                                                                                                      The email address with the password to be reset.

                                                                                                                                                                                                                                                                                      Parameter actionCodeSettings

                                                                                                                                                                                                                                                                                      The action code settings. If specified, the state/continue URL will be set as the "continueUrl" parameter in the password reset link. The default password reset landing page will use this to display a link to go back to the app if it is installed. If the actionCodeSettings is not specified, no URL is appended to the action URL. The state URL provided must belong to a domain that is whitelisted by the developer in the console. Otherwise an error will be thrown. Mobile app redirects will only be applicable if the developer configures and accepts the Firebase Dynamic Links terms of condition. The Android package name and iOS bundle ID will be respected only if they are configured in the same Firebase Auth project used.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      var actionCodeSettings = {
                                                                                                                                                                                                                                                                                      url: 'https://www.example.com/?email=user@example.com',
                                                                                                                                                                                                                                                                                      iOS: {
                                                                                                                                                                                                                                                                                      bundleId: 'com.example.ios'
                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                      android: {
                                                                                                                                                                                                                                                                                      packageName: 'com.example.android',
                                                                                                                                                                                                                                                                                      installApp: true,
                                                                                                                                                                                                                                                                                      minimumVersion: '12'
                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                      handleCodeInApp: true
                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                      firebase.auth().sendPasswordResetEmail(
                                                                                                                                                                                                                                                                                      'user@example.com', actionCodeSettings)
                                                                                                                                                                                                                                                                                      .then(function() {
                                                                                                                                                                                                                                                                                      // Password reset email sent.
                                                                                                                                                                                                                                                                                      })
                                                                                                                                                                                                                                                                                      .catch(function(error) {
                                                                                                                                                                                                                                                                                      // Error occurred. Inspect error.code.
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                    method sendSignInLinkToEmail

                                                                                                                                                                                                                                                                                    sendSignInLinkToEmail: (
                                                                                                                                                                                                                                                                                    email: string,
                                                                                                                                                                                                                                                                                    actionCodeSettings: ActionCodeSettings
                                                                                                                                                                                                                                                                                    ) => Promise<void>;
                                                                                                                                                                                                                                                                                    • Sends a sign-in email link to the user with the specified email.

                                                                                                                                                                                                                                                                                      The sign-in operation has to always be completed in the app unlike other out of band email actions (password reset and email verifications). This is because, at the end of the flow, the user is expected to be signed in and their Auth state persisted within the app.

                                                                                                                                                                                                                                                                                      To complete sign in with the email link, call firebase.auth.Auth.signInWithEmailLink with the email address and the email link supplied in the email sent to the user.

                                                                                                                                                                                                                                                                                      Error Codes auth/argument-error Thrown if handleCodeInApp is false. auth/invalid-email Thrown if the email address is not valid. auth/missing-android-pkg-name An Android package name must be provided if the Android app is required to be installed. auth/missing-continue-uri A continue URL must be provided in the request. auth/missing-ios-bundle-id An iOS Bundle ID must be provided if an App Store ID is provided. auth/invalid-continue-uri The continue URL provided in the request is invalid. auth/unauthorized-continue-uri The domain of the continue URL is not whitelisted. Whitelist the domain in the Firebase console.

                                                                                                                                                                                                                                                                                      Parameter email

                                                                                                                                                                                                                                                                                      The email account to sign in with.

                                                                                                                                                                                                                                                                                      Parameter actionCodeSettings

                                                                                                                                                                                                                                                                                      The action code settings. The action code settings which provides Firebase with instructions on how to construct the email link. This includes the sign in completion URL or the deep link for mobile redirects, the mobile apps to use when the sign-in link is opened on an Android or iOS device. Mobile app redirects will only be applicable if the developer configures and accepts the Firebase Dynamic Links terms of condition. The Android package name and iOS bundle ID will be respected only if they are configured in the same Firebase Auth project used.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      var actionCodeSettings = {
                                                                                                                                                                                                                                                                                      // The URL to redirect to for sign-in completion. This is also the deep
                                                                                                                                                                                                                                                                                      // link for mobile redirects. The domain (www.example.com) for this URL
                                                                                                                                                                                                                                                                                      // must be whitelisted in the Firebase Console.
                                                                                                                                                                                                                                                                                      url: 'https://www.example.com/finishSignUp?cartId=1234',
                                                                                                                                                                                                                                                                                      iOS: {
                                                                                                                                                                                                                                                                                      bundleId: 'com.example.ios'
                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                      android: {
                                                                                                                                                                                                                                                                                      packageName: 'com.example.android',
                                                                                                                                                                                                                                                                                      installApp: true,
                                                                                                                                                                                                                                                                                      minimumVersion: '12'
                                                                                                                                                                                                                                                                                      },
                                                                                                                                                                                                                                                                                      // This must be true.
                                                                                                                                                                                                                                                                                      handleCodeInApp: true
                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                      firebase.auth().sendSignInLinkToEmail('user@example.com', actionCodeSettings)
                                                                                                                                                                                                                                                                                      .then(function() {
                                                                                                                                                                                                                                                                                      // The link was successfully sent. Inform the user. Save the email
                                                                                                                                                                                                                                                                                      // locally so you don't need to ask the user for it again if they open
                                                                                                                                                                                                                                                                                      // the link on the same device.
                                                                                                                                                                                                                                                                                      })
                                                                                                                                                                                                                                                                                      .catch(function(error) {
                                                                                                                                                                                                                                                                                      // Some error occurred, you can inspect the code: error.code
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                    method setPersistence

                                                                                                                                                                                                                                                                                    setPersistence: (persistence: string) => Promise<void>;
                                                                                                                                                                                                                                                                                    • Changes the current type of persistence on the current Auth instance for the currently saved Auth session and applies this type of persistence for future sign-in requests, including sign-in with redirect requests. This will return a promise that will resolve once the state finishes copying from one type of storage to the other. Calling a sign-in method after changing persistence will wait for that persistence change to complete before applying it on the new Auth state.

                                                                                                                                                                                                                                                                                      This makes it easy for a user signing in to specify whether their session should be remembered or not. It also makes it easier to never persist the Auth state for applications that are shared by other users or have sensitive data.

                                                                                                                                                                                                                                                                                      The default for web browser apps and React Native apps is 'local' (provided the browser supports this mechanism) whereas it is 'none' for Node.js backend apps.

                                                                                                                                                                                                                                                                                      Error Codes (thrown synchronously) auth/invalid-persistence-type Thrown if the specified persistence type is invalid. auth/unsupported-persistence-type Thrown if the current environment does not support the specified persistence type.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      firebase.auth().setPersistence(firebase.auth.Auth.Persistence.SESSION)
                                                                                                                                                                                                                                                                                      .then(function() {
                                                                                                                                                                                                                                                                                      // Existing and future Auth states are now persisted in the current
                                                                                                                                                                                                                                                                                      // session only. Closing the window would clear any existing state even if
                                                                                                                                                                                                                                                                                      // a user forgets to sign out.
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                    method signInAndRetrieveDataWithCredential

                                                                                                                                                                                                                                                                                    signInAndRetrieveDataWithCredential: (
                                                                                                                                                                                                                                                                                    credential: AuthCredential
                                                                                                                                                                                                                                                                                    ) => Promise<UserCredential>;
                                                                                                                                                                                                                                                                                    • Asynchronously signs in with the given credentials, and returns any available additional user information, such as user name.

                                                                                                                                                                                                                                                                                      Error Codes auth/account-exists-with-different-credential Thrown if there already exists an account with the email address asserted by the credential. Resolve this by calling firebase.auth.Auth.fetchSignInMethodsForEmail and then asking the user to sign in using one of the returned providers. Once the user is signed in, the original credential can be linked to the user with firebase.User.linkWithCredential. auth/invalid-credential Thrown if the credential is malformed or has expired. auth/operation-not-allowed Thrown if the type of account corresponding to the credential is not enabled. Enable the account type in the Firebase Console, under the Auth tab. auth/user-disabled Thrown if the user corresponding to the given credential has been disabled. auth/user-not-found Thrown if signing in with a credential from firebase.auth.EmailAuthProvider.credential and there is no user corresponding to the given email. auth/wrong-password Thrown if signing in with a credential from firebase.auth.EmailAuthProvider.credential and the password is invalid for the given email, or if the account corresponding to the email does not have a password set. auth/invalid-verification-code Thrown if the credential is a firebase.auth.PhoneAuthProvider.credential and the verification code of the credential is not valid. auth/invalid-verification-id Thrown if the credential is a firebase.auth.PhoneAuthProvider.credential and the verification ID of the credential is not valid.

                                                                                                                                                                                                                                                                                      Parameter credential

                                                                                                                                                                                                                                                                                      The auth credential.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      firebase.auth().signInAndRetrieveDataWithCredential(credential)
                                                                                                                                                                                                                                                                                      .then(function(userCredential) {
                                                                                                                                                                                                                                                                                      console.log(userCredential.additionalUserInfo.username);
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                      Deprecated

                                                                                                                                                                                                                                                                                      This method is deprecated. Use firebase.auth.Auth.signInWithCredential instead.

                                                                                                                                                                                                                                                                                    method signInAnonymously

                                                                                                                                                                                                                                                                                    signInAnonymously: () => Promise<UserCredential>;
                                                                                                                                                                                                                                                                                    • Asynchronously signs in as an anonymous user.

                                                                                                                                                                                                                                                                                      If there is already an anonymous user signed in, that user will be returned; otherwise, a new anonymous user identity will be created and returned.

                                                                                                                                                                                                                                                                                      Error Codes auth/operation-not-allowed Thrown if anonymous accounts are not enabled. Enable anonymous accounts in the Firebase Console, under the Auth tab.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      firebase.auth().signInAnonymously().catch(function(error) {
                                                                                                                                                                                                                                                                                      // Handle Errors here.
                                                                                                                                                                                                                                                                                      var errorCode = error.code;
                                                                                                                                                                                                                                                                                      var errorMessage = error.message;
                                                                                                                                                                                                                                                                                      if (errorCode === 'auth/operation-not-allowed') {
                                                                                                                                                                                                                                                                                      alert('You must enable Anonymous auth in the Firebase Console.');
                                                                                                                                                                                                                                                                                      } else {
                                                                                                                                                                                                                                                                                      console.error(error);
                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                    method signInWithCredential

                                                                                                                                                                                                                                                                                    signInWithCredential: (credential: AuthCredential) => Promise<UserCredential>;
                                                                                                                                                                                                                                                                                    • Asynchronously signs in with the given credentials.

                                                                                                                                                                                                                                                                                      Error Codes auth/account-exists-with-different-credential Thrown if there already exists an account with the email address asserted by the credential. Resolve this by calling firebase.auth.Auth.fetchSignInMethodsForEmail and then asking the user to sign in using one of the returned providers. Once the user is signed in, the original credential can be linked to the user with firebase.User.linkWithCredential. auth/invalid-credential Thrown if the credential is malformed or has expired. auth/operation-not-allowed Thrown if the type of account corresponding to the credential is not enabled. Enable the account type in the Firebase Console, under the Auth tab. auth/user-disabled Thrown if the user corresponding to the given credential has been disabled. auth/user-not-found Thrown if signing in with a credential from firebase.auth.EmailAuthProvider.credential and there is no user corresponding to the given email. auth/wrong-password Thrown if signing in with a credential from firebase.auth.EmailAuthProvider.credential and the password is invalid for the given email, or if the account corresponding to the email does not have a password set. auth/invalid-verification-code Thrown if the credential is a firebase.auth.PhoneAuthProvider.credential and the verification code of the credential is not valid. auth/invalid-verification-id Thrown if the credential is a firebase.auth.PhoneAuthProvider.credential and the verification ID of the credential is not valid.

                                                                                                                                                                                                                                                                                      Parameter credential

                                                                                                                                                                                                                                                                                      The auth credential.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      firebase.auth().signInWithCredential(credential).catch(function(error) {
                                                                                                                                                                                                                                                                                      // Handle Errors here.
                                                                                                                                                                                                                                                                                      var errorCode = error.code;
                                                                                                                                                                                                                                                                                      var errorMessage = error.message;
                                                                                                                                                                                                                                                                                      // The email of the user's account used.
                                                                                                                                                                                                                                                                                      var email = error.email;
                                                                                                                                                                                                                                                                                      // The firebase.auth.AuthCredential type that was used.
                                                                                                                                                                                                                                                                                      var credential = error.credential;
                                                                                                                                                                                                                                                                                      if (errorCode === 'auth/account-exists-with-different-credential') {
                                                                                                                                                                                                                                                                                      alert('Email already associated with another account.');
                                                                                                                                                                                                                                                                                      // Handle account linking here, if using.
                                                                                                                                                                                                                                                                                      } else {
                                                                                                                                                                                                                                                                                      console.error(error);
                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                    method signInWithCustomToken

                                                                                                                                                                                                                                                                                    signInWithCustomToken: (token: string) => Promise<UserCredential>;
                                                                                                                                                                                                                                                                                    • Asynchronously signs in using a custom token.

                                                                                                                                                                                                                                                                                      Custom tokens are used to integrate Firebase Auth with existing auth systems, and must be generated by the auth backend.

                                                                                                                                                                                                                                                                                      Fails with an error if the token is invalid, expired, or not accepted by the Firebase Auth service.

                                                                                                                                                                                                                                                                                      Error Codes auth/custom-token-mismatch Thrown if the custom token is for a different Firebase App. auth/invalid-custom-token Thrown if the custom token format is incorrect.

                                                                                                                                                                                                                                                                                      Parameter token

                                                                                                                                                                                                                                                                                      The custom token to sign in with.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      firebase.auth().signInWithCustomToken(token).catch(function(error) {
                                                                                                                                                                                                                                                                                      // Handle Errors here.
                                                                                                                                                                                                                                                                                      var errorCode = error.code;
                                                                                                                                                                                                                                                                                      var errorMessage = error.message;
                                                                                                                                                                                                                                                                                      if (errorCode === 'auth/invalid-custom-token') {
                                                                                                                                                                                                                                                                                      alert('The token you provided is not valid.');
                                                                                                                                                                                                                                                                                      } else {
                                                                                                                                                                                                                                                                                      console.error(error);
                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                    method signInWithEmailAndPassword

                                                                                                                                                                                                                                                                                    signInWithEmailAndPassword: (
                                                                                                                                                                                                                                                                                    email: string,
                                                                                                                                                                                                                                                                                    password: string
                                                                                                                                                                                                                                                                                    ) => Promise<UserCredential>;
                                                                                                                                                                                                                                                                                    • Asynchronously signs in using an email and password.

                                                                                                                                                                                                                                                                                      Fails with an error if the email address and password do not match.

                                                                                                                                                                                                                                                                                      Note: The user's password is NOT the password used to access the user's email account. The email address serves as a unique identifier for the user, and the password is used to access the user's account in your Firebase project.

                                                                                                                                                                                                                                                                                      See also: firebase.auth.Auth.createUserWithEmailAndPassword.

                                                                                                                                                                                                                                                                                      Error Codes auth/invalid-email Thrown if the email address is not valid. auth/user-disabled Thrown if the user corresponding to the given email has been disabled. auth/user-not-found Thrown if there is no user corresponding to the given email. auth/wrong-password Thrown if the password is invalid for the given email, or the account corresponding to the email does not have a password set.

                                                                                                                                                                                                                                                                                      Parameter email

                                                                                                                                                                                                                                                                                      The users email address.

                                                                                                                                                                                                                                                                                      Parameter password

                                                                                                                                                                                                                                                                                      The users password.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      firebase.auth().signInWithEmailAndPassword(email, password)
                                                                                                                                                                                                                                                                                      .catch(function(error) {
                                                                                                                                                                                                                                                                                      // Handle Errors here.
                                                                                                                                                                                                                                                                                      var errorCode = error.code;
                                                                                                                                                                                                                                                                                      var errorMessage = error.message;
                                                                                                                                                                                                                                                                                      if (errorCode === 'auth/wrong-password') {
                                                                                                                                                                                                                                                                                      alert('Wrong password.');
                                                                                                                                                                                                                                                                                      } else {
                                                                                                                                                                                                                                                                                      alert(errorMessage);
                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                      console.log(error);
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                    signInWithEmailLink: (
                                                                                                                                                                                                                                                                                    email: string,
                                                                                                                                                                                                                                                                                    emailLink?: string
                                                                                                                                                                                                                                                                                    ) => Promise<UserCredential>;
                                                                                                                                                                                                                                                                                    • Asynchronously signs in using an email and sign-in email link. If no link is passed, the link is inferred from the current URL.

                                                                                                                                                                                                                                                                                      Fails with an error if the email address is invalid or OTP in email link expires.

                                                                                                                                                                                                                                                                                      Note: Confirm the link is a sign-in email link before calling this method firebase.auth.Auth.isSignInWithEmailLink.

                                                                                                                                                                                                                                                                                      Error Codes auth/expired-action-code Thrown if OTP in email link expires. auth/invalid-email Thrown if the email address is not valid. auth/user-disabled Thrown if the user corresponding to the given email has been disabled.

                                                                                                                                                                                                                                                                                      Parameter email

                                                                                                                                                                                                                                                                                      The email account to sign in with.

                                                                                                                                                                                                                                                                                      Parameter emailLink

                                                                                                                                                                                                                                                                                      The optional link which contains the OTP needed to complete the sign in with email link. If not specified, the current URL is used instead.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      firebase.auth().signInWithEmailLink(email, emailLink)
                                                                                                                                                                                                                                                                                      .catch(function(error) {
                                                                                                                                                                                                                                                                                      // Some error occurred, you can inspect the code: error.code
                                                                                                                                                                                                                                                                                      // Common errors could be invalid email and invalid or expired OTPs.
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                    method signInWithPhoneNumber

                                                                                                                                                                                                                                                                                    signInWithPhoneNumber: (
                                                                                                                                                                                                                                                                                    phoneNumber: string,
                                                                                                                                                                                                                                                                                    applicationVerifier: ApplicationVerifier
                                                                                                                                                                                                                                                                                    ) => Promise<ConfirmationResult>;
                                                                                                                                                                                                                                                                                    • Asynchronously signs in using a phone number. This method sends a code via SMS to the given phone number, and returns a firebase.auth.ConfirmationResult. After the user provides the code sent to their phone, call firebase.auth.ConfirmationResult.confirm with the code to sign the user in.

                                                                                                                                                                                                                                                                                      For abuse prevention, this method also requires a firebase.auth.ApplicationVerifier. The Firebase Auth SDK includes a reCAPTCHA-based implementation, firebase.auth.RecaptchaVerifier.

                                                                                                                                                                                                                                                                                      Error Codes auth/captcha-check-failed Thrown if the reCAPTCHA response token was invalid, expired, or if this method was called from a non-whitelisted domain. auth/invalid-phone-number Thrown if the phone number has an invalid format. auth/missing-phone-number Thrown if the phone number is missing. auth/quota-exceeded Thrown if the SMS quota for the Firebase project has been exceeded. auth/user-disabled Thrown if the user corresponding to the given phone number has been disabled. auth/operation-not-allowed Thrown if you have not enabled the provider in the Firebase Console. Go to the Firebase Console for your project, in the Auth section and the Sign in Method tab and configure the provider.

                                                                                                                                                                                                                                                                                      Parameter phoneNumber

                                                                                                                                                                                                                                                                                      The user's phone number in E.164 format (e.g. +16505550101).

                                                                                                                                                                                                                                                                                      Parameter applicationVerifier

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      // 'recaptcha-container' is the ID of an element in the DOM.
                                                                                                                                                                                                                                                                                      var applicationVerifier = new firebase.auth.RecaptchaVerifier(
                                                                                                                                                                                                                                                                                      'recaptcha-container');
                                                                                                                                                                                                                                                                                      firebase.auth().signInWithPhoneNumber(phoneNumber, applicationVerifier)
                                                                                                                                                                                                                                                                                      .then(function(confirmationResult) {
                                                                                                                                                                                                                                                                                      var verificationCode = window.prompt('Please enter the verification ' +
                                                                                                                                                                                                                                                                                      'code that was sent to your mobile device.');
                                                                                                                                                                                                                                                                                      return confirmationResult.confirm(verificationCode);
                                                                                                                                                                                                                                                                                      })
                                                                                                                                                                                                                                                                                      .catch(function(error) {
                                                                                                                                                                                                                                                                                      // Handle Errors here.
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                    method signInWithPopup

                                                                                                                                                                                                                                                                                    signInWithPopup: (provider: AuthProvider) => Promise<UserCredential>;
                                                                                                                                                                                                                                                                                    • Authenticates a Firebase client using a popup-based OAuth authentication flow.

                                                                                                                                                                                                                                                                                      If succeeds, returns the signed in user along with the provider's credential. If sign in was unsuccessful, returns an error object containing additional information about the error.

                                                                                                                                                                                                                                                                                      Error Codes auth/account-exists-with-different-credential Thrown if there already exists an account with the email address asserted by the credential. Resolve this by calling firebase.auth.Auth.fetchSignInMethodsForEmail with the error.email and then asking the user to sign in using one of the returned providers. Once the user is signed in, the original credential retrieved from the error.credential can be linked to the user with firebase.User.linkWithCredential to prevent the user from signing in again to the original provider via popup or redirect. If you are using redirects for sign in, save the credential in session storage and then retrieve on redirect and repopulate the credential using for example firebase.auth.GoogleAuthProvider.credential depending on the credential provider id and complete the link. auth/auth-domain-config-required Thrown if authDomain configuration is not provided when calling firebase.initializeApp(). Check Firebase Console for instructions on determining and passing that field. auth/cancelled-popup-request Thrown if successive popup operations are triggered. Only one popup request is allowed at one time. All the popups would fail with this error except for the last one. auth/operation-not-allowed Thrown if the type of account corresponding to the credential is not enabled. Enable the account type in the Firebase Console, under the Auth tab. auth/operation-not-supported-in-this-environment Thrown if this operation is not supported in the environment your application is running on. "location.protocol" must be http or https. auth/popup-blocked Thrown if the popup was blocked by the browser, typically when this operation is triggered outside of a click handler. auth/popup-closed-by-user Thrown if the popup window is closed by the user without completing the sign in to the provider. auth/unauthorized-domain Thrown if the app domain is not authorized for OAuth operations for your Firebase project. Edit the list of authorized domains from the Firebase console.

                                                                                                                                                                                                                                                                                      This method does not work in a Node.js environment.

                                                                                                                                                                                                                                                                                      Parameter provider

                                                                                                                                                                                                                                                                                      The provider to authenticate. The provider has to be an OAuth provider. Non-OAuth providers like firebase.auth.EmailAuthProvider will throw an error.

                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                      // Creates the provider object.
                                                                                                                                                                                                                                                                                      var provider = new firebase.auth.FacebookAuthProvider();
                                                                                                                                                                                                                                                                                      // You can add additional scopes to the provider:
                                                                                                                                                                                                                                                                                      provider.addScope('email');
                                                                                                                                                                                                                                                                                      provider.addScope('user_friends');
                                                                                                                                                                                                                                                                                      // Sign in with popup:
                                                                                                                                                                                                                                                                                      auth.signInWithPopup(provider).then(function(result) {
                                                                                                                                                                                                                                                                                      // The firebase.User instance:
                                                                                                                                                                                                                                                                                      var user = result.user;
                                                                                                                                                                                                                                                                                      // The Facebook firebase.auth.AuthCredential containing the Facebook
                                                                                                                                                                                                                                                                                      // access token:
                                                                                                                                                                                                                                                                                      var credential = result.credential;
                                                                                                                                                                                                                                                                                      }, function(error) {
                                                                                                                                                                                                                                                                                      // The provider's account email, can be used in case of
                                                                                                                                                                                                                                                                                      // auth/account-exists-with-different-credential to fetch the providers
                                                                                                                                                                                                                                                                                      // linked to the email:
                                                                                                                                                                                                                                                                                      var email = error.email;
                                                                                                                                                                                                                                                                                      // The provider's credential:
                                                                                                                                                                                                                                                                                      var credential = error.credential;
                                                                                                                                                                                                                                                                                      // In case of auth/account-exists-with-different-credential error,
                                                                                                                                                                                                                                                                                      // you can fetch the providers using this:
                                                                                                                                                                                                                                                                                      if (error.code === 'auth/account-exists-with-different-credential') {
                                                                                                                                                                                                                                                                                      auth.fetchSignInMethodsForEmail(email).then(function(providers) {
                                                                                                                                                                                                                                                                                      // The returned 'providers' is a list of the available providers
                                                                                                                                                                                                                                                                                      // linked to the email address. Please refer to the guide for a more
                                                                                                                                                                                                                                                                                      // complete explanation on how to recover from this error.
                                                                                                                                                                                                                                                                                      });
                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                    method signInWithRedirect

                                                                                                                                                                                                                                                                                    signInWithRedirect: (provider: AuthProvider) => Promise<void>;
                                                                                                                                                                                                                                                                                    • Authenticates a Firebase client using a full-page redirect flow. To handle the results and errors for this operation, refer to firebase.auth.Auth.getRedirectResult.

                                                                                                                                                                                                                                                                                      Error Codes auth/auth-domain-config-required Thrown if authDomain configuration is not provided when calling firebase.initializeApp(). Check Firebase Console for instructions on determining and passing that field. auth/operation-not-supported-in-this-environment Thrown if this operation is not supported in the environment your application is running on. "location.protocol" must be http or https. auth/unauthorized-domain Thrown if the app domain is not authorized for OAuth operations for your Firebase project. Edit the list of authorized domains from the Firebase console.

                                                                                                                                                                                                                                                                                      This method does not work in a Node.js environment.

                                                                                                                                                                                                                                                                                      Parameter provider

                                                                                                                                                                                                                                                                                      The provider to authenticate. The provider has to be an OAuth provider. Non-OAuth providers like firebase.auth.EmailAuthProvider will throw an error.

                                                                                                                                                                                                                                                                                    method signOut

                                                                                                                                                                                                                                                                                    signOut: () => Promise<void>;
                                                                                                                                                                                                                                                                                    • Signs out the current user.

                                                                                                                                                                                                                                                                                    method updateCurrentUser

                                                                                                                                                                                                                                                                                    updateCurrentUser: (user: firebase.User | null) => Promise<void>;
                                                                                                                                                                                                                                                                                    • Asynchronously sets the provided user as currentUser on the current Auth instance. A new instance copy of the user provided will be made and set as currentUser.

                                                                                                                                                                                                                                                                                      This will trigger firebase.auth.Auth.onAuthStateChanged and firebase.auth.Auth.onIdTokenChanged listeners like other sign in methods.

                                                                                                                                                                                                                                                                                      The operation fails with an error if the user to be updated belongs to a different Firebase project.

                                                                                                                                                                                                                                                                                      Error Codes auth/invalid-user-token Thrown if the user to be updated belongs to a different Firebase project. auth/user-token-expired Thrown if the token of the user to be updated is expired. auth/null-user Thrown if the user to be updated is null. auth/tenant-id-mismatch Thrown if the provided user's tenant ID does not match the underlying Auth instance's configured tenant ID

                                                                                                                                                                                                                                                                                    method useDeviceLanguage

                                                                                                                                                                                                                                                                                    useDeviceLanguage: () => void;
                                                                                                                                                                                                                                                                                    • Sets the current language to the default device/browser preference.

                                                                                                                                                                                                                                                                                    method useEmulator

                                                                                                                                                                                                                                                                                    useEmulator: (url: string) => void;
                                                                                                                                                                                                                                                                                    • Modify this Auth instance to communicate with the Firebase Auth emulator. This must be called synchronously immediately following the first call to firebase.auth(). Do not use with production credentials as emulator traffic is not encrypted.

                                                                                                                                                                                                                                                                                      Parameter url

                                                                                                                                                                                                                                                                                      The URL at which the emulator is running (eg, 'http://localhost:9099')

                                                                                                                                                                                                                                                                                    method verifyPasswordResetCode

                                                                                                                                                                                                                                                                                    verifyPasswordResetCode: (code: string) => Promise<string>;
                                                                                                                                                                                                                                                                                    • Checks a password reset code sent to the user by email or other out-of-band mechanism.

                                                                                                                                                                                                                                                                                      Returns the user's email address if valid.

                                                                                                                                                                                                                                                                                      Error Codes auth/expired-action-code Thrown if the password reset code has expired. auth/invalid-action-code Thrown if the password reset code is invalid. This can happen if the code is malformed or has already been used. auth/user-disabled Thrown if the user corresponding to the given password reset code has been disabled. auth/user-not-found Thrown if there is no user corresponding to the password reset code. This may have happened if the user was deleted between when the code was issued and when this method was called.

                                                                                                                                                                                                                                                                                      Parameter code

                                                                                                                                                                                                                                                                                      A verification code sent to the user.

                                                                                                                                                                                                                                                                                    interface AuthError

                                                                                                                                                                                                                                                                                    interface AuthError extends firebase.auth.Error {}
                                                                                                                                                                                                                                                                                    • The account conflict error. Refer to firebase.auth.Auth.signInWithPopup for more information.

                                                                                                                                                                                                                                                                                      Common Error Codes auth/account-exists-with-different-credential Thrown if there already exists an account with the email address asserted by the credential. Resolve this by calling firebase.auth.Auth.fetchSignInMethodsForEmail with the error.email and then asking the user to sign in using one of the returned providers. Once the user is signed in, the original credential retrieved from the error.credential can be linked to the user with firebase.User.linkWithCredential to prevent the user from signing in again to the original provider via popup or redirect. If you are using redirects for sign in, save the credential in session storage and then retrieve on redirect and repopulate the credential using for example firebase.auth.GoogleAuthProvider.credential depending on the credential provider id and complete the link. auth/credential-already-in-use Thrown if the account corresponding to the credential already exists among your users, or is already linked to a Firebase User. For example, this error could be thrown if you are upgrading an anonymous user to a Google user by linking a Google credential to it and the Google credential used is already associated with an existing Firebase Google user. The fields error.email, error.phoneNumber, and error.credential (firebase.auth.AuthCredential) may be provided, depending on the type of credential. You can recover from this error by signing in with error.credential directly via firebase.auth.Auth.signInWithCredential. auth/email-already-in-use Thrown if the email corresponding to the credential already exists among your users. When thrown while linking a credential to an existing user, an error.email and error.credential (firebase.auth.AuthCredential) fields are also provided. You have to link the credential to the existing user with that email if you wish to continue signing in with that credential. To do so, call firebase.auth.Auth.fetchSignInMethodsForEmail, sign in to error.email via one of the providers returned and then firebase.User.linkWithCredential the original credential to that newly signed in user.

                                                                                                                                                                                                                                                                                    property credential

                                                                                                                                                                                                                                                                                    credential?: firebase.auth.AuthCredential;

                                                                                                                                                                                                                                                                                    property email

                                                                                                                                                                                                                                                                                    email?: string;
                                                                                                                                                                                                                                                                                    • The email of the user's account used for sign-in/linking.

                                                                                                                                                                                                                                                                                    property phoneNumber

                                                                                                                                                                                                                                                                                    phoneNumber?: string;
                                                                                                                                                                                                                                                                                    • The phone number of the user's account used for sign-in/linking.

                                                                                                                                                                                                                                                                                    property tenantId

                                                                                                                                                                                                                                                                                    tenantId?: string;
                                                                                                                                                                                                                                                                                    • The tenant ID being used for sign-in/linking. If you use firebase.auth.Auth.signInWithRedirect to sign in, you have to set the tenant ID on Auth instance again as the tenant ID is not persisted after redirection.

                                                                                                                                                                                                                                                                                    interface AuthProvider

                                                                                                                                                                                                                                                                                    interface AuthProvider {}
                                                                                                                                                                                                                                                                                    • Interface that represents an auth provider.

                                                                                                                                                                                                                                                                                    property providerId

                                                                                                                                                                                                                                                                                    providerId: string;

                                                                                                                                                                                                                                                                                      interface AuthSettings

                                                                                                                                                                                                                                                                                      interface AuthSettings {}
                                                                                                                                                                                                                                                                                      • Interface representing an Auth instance's settings, currently used for enabling/disabling app verification for phone Auth testing.

                                                                                                                                                                                                                                                                                      property appVerificationDisabledForTesting

                                                                                                                                                                                                                                                                                      appVerificationDisabledForTesting: boolean;
                                                                                                                                                                                                                                                                                      • When set, this property disables app verification for the purpose of testing phone authentication. For this property to take effect, it needs to be set before rendering a reCAPTCHA app verifier. When this is disabled, a mock reCAPTCHA is rendered instead. This is useful for manual testing during development or for automated integration tests.

                                                                                                                                                                                                                                                                                        In order to use this feature, you will need to via the Firebase Console.

                                                                                                                                                                                                                                                                                        The default value is false (app verification is enabled).

                                                                                                                                                                                                                                                                                      interface Config

                                                                                                                                                                                                                                                                                      interface Config {}
                                                                                                                                                                                                                                                                                      • Interface representing the Auth config.

                                                                                                                                                                                                                                                                                        Modifiers

                                                                                                                                                                                                                                                                                        • @public

                                                                                                                                                                                                                                                                                      property apiHost

                                                                                                                                                                                                                                                                                      apiHost: string;
                                                                                                                                                                                                                                                                                      • The host at which the Firebase Auth backend is running.

                                                                                                                                                                                                                                                                                      property apiKey

                                                                                                                                                                                                                                                                                      apiKey: string;
                                                                                                                                                                                                                                                                                      • The API Key used to communicate with the Firebase Auth backend.

                                                                                                                                                                                                                                                                                      property apiScheme

                                                                                                                                                                                                                                                                                      apiScheme: string;
                                                                                                                                                                                                                                                                                      • The scheme used to communicate with the Firebase Auth backend.

                                                                                                                                                                                                                                                                                      property authDomain

                                                                                                                                                                                                                                                                                      authDomain?: string;
                                                                                                                                                                                                                                                                                      • The domain at which the web widgets are hosted (provided via Firebase Config).

                                                                                                                                                                                                                                                                                      property sdkClientVersion

                                                                                                                                                                                                                                                                                      sdkClientVersion: string;
                                                                                                                                                                                                                                                                                      • The SDK Client Version.

                                                                                                                                                                                                                                                                                      property tokenApiHost

                                                                                                                                                                                                                                                                                      tokenApiHost: string;
                                                                                                                                                                                                                                                                                      • The host at which the Secure Token API is running.

                                                                                                                                                                                                                                                                                      interface ConfirmationResult

                                                                                                                                                                                                                                                                                      interface ConfirmationResult {}
                                                                                                                                                                                                                                                                                      • A result from a phone number sign-in, link, or reauthenticate call.

                                                                                                                                                                                                                                                                                      property verificationId

                                                                                                                                                                                                                                                                                      verificationId: string;
                                                                                                                                                                                                                                                                                      • The phone number authentication operation's verification ID. This can be used along with the verification code to initialize a phone auth credential.

                                                                                                                                                                                                                                                                                      method confirm

                                                                                                                                                                                                                                                                                      confirm: (verificationCode: string) => Promise<UserCredential>;
                                                                                                                                                                                                                                                                                      • Finishes a phone number sign-in, link, or reauthentication, given the code that was sent to the user's mobile device.

                                                                                                                                                                                                                                                                                        Error Codes auth/invalid-verification-code Thrown if the verification code is not valid. auth/missing-verification-code Thrown if the verification code is missing.

                                                                                                                                                                                                                                                                                      interface EmulatorConfig

                                                                                                                                                                                                                                                                                      interface EmulatorConfig {}
                                                                                                                                                                                                                                                                                      • Configuration of Firebase Authentication Emulator.

                                                                                                                                                                                                                                                                                      property host

                                                                                                                                                                                                                                                                                      readonly host: string;
                                                                                                                                                                                                                                                                                      • The hostname of the emulator, which may be a domain ("localhost"), IPv4 address ("127.0.0.1") or quoted IPv6 address ("[::1]").

                                                                                                                                                                                                                                                                                      property options

                                                                                                                                                                                                                                                                                      readonly options: {
                                                                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                                                                      * Whether the warning banner attached to the DOM was disabled.
                                                                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                                                                      readonly disableWarnings: boolean;
                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                      • The emulator-specific options.

                                                                                                                                                                                                                                                                                      property port

                                                                                                                                                                                                                                                                                      readonly port: number | null;
                                                                                                                                                                                                                                                                                      • The port of the emulator, or null if port isn't specified (i.e. protocol default).

                                                                                                                                                                                                                                                                                      property protocol

                                                                                                                                                                                                                                                                                      readonly protocol: string;
                                                                                                                                                                                                                                                                                      • The protocol used to communicate with the emulator ("http"/"https").

                                                                                                                                                                                                                                                                                      interface Error

                                                                                                                                                                                                                                                                                      interface Error {}
                                                                                                                                                                                                                                                                                      • An authentication error. For method-specific error codes, refer to the specific methods in the documentation. For common error codes, check the reference below. Usefirebase.auth.Error.code to get the specific error code. For a detailed message, use firebase.auth.Error.message. Errors with the code auth/account-exists-with-different-credential will have the additional fields email and credential which are needed to provide a way to resolve these specific errors. Refer to firebase.auth.Auth.signInWithPopup for more information.

                                                                                                                                                                                                                                                                                        Common Error Codes auth/app-deleted Thrown if the instance of FirebaseApp has been deleted. auth/app-not-authorized Thrown if the app identified by the domain where it's hosted, is not authorized to use Firebase Authentication with the provided API key. Review your key configuration in the Google API console. auth/argument-error Thrown if a method is called with incorrect arguments. auth/invalid-api-key Thrown if the provided API key is invalid. Please check that you have copied it correctly from the Firebase Console. auth/invalid-user-token Thrown if the user's credential is no longer valid. The user must sign in again. auth/invalid-tenant-id Thrown if the tenant ID provided is invalid. auth/network-request-failed Thrown if a network error (such as timeout, interrupted connection or unreachable host) has occurred. auth/operation-not-allowed Thrown if you have not enabled the provider in the Firebase Console. Go to the Firebase Console for your project, in the Auth section and the Sign in Method tab and configure the provider. auth/requires-recent-login Thrown if the user's last sign-in time does not meet the security threshold. Use firebase.User.reauthenticateWithCredential to resolve. This does not apply if the user is anonymous. auth/too-many-requests Thrown if requests are blocked from a device due to unusual activity. Trying again after some delay would unblock. auth/unauthorized-domain Thrown if the app domain is not authorized for OAuth operations for your Firebase project. Edit the list of authorized domains from the Firebase console. auth/user-disabled Thrown if the user account has been disabled by an administrator. Accounts can be enabled or disabled in the Firebase Console, the Auth section and Users subsection. auth/user-token-expired Thrown if the user's credential has expired. This could also be thrown if a user has been deleted. Prompting the user to sign in again should resolve this for either case. auth/web-storage-unsupported Thrown if the browser does not support web storage or if the user disables them.

                                                                                                                                                                                                                                                                                      property code

                                                                                                                                                                                                                                                                                      code: string;
                                                                                                                                                                                                                                                                                      • Unique error code.

                                                                                                                                                                                                                                                                                      property message

                                                                                                                                                                                                                                                                                      message: string;
                                                                                                                                                                                                                                                                                      • Complete error message.

                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                                        interface IdTokenResult

                                                                                                                                                                                                                                                                                        interface IdTokenResult {}
                                                                                                                                                                                                                                                                                        • Interface representing ID token result obtained from firebase.User.getIdTokenResult. It contains the ID token JWT string and other helper properties for getting different data associated with the token as well as all the decoded payload claims.

                                                                                                                                                                                                                                                                                          Note that these claims are not to be trusted as they are parsed client side. Only server side verification can guarantee the integrity of the token claims.

                                                                                                                                                                                                                                                                                        property authTime

                                                                                                                                                                                                                                                                                        authTime: string;
                                                                                                                                                                                                                                                                                        • The authentication time formatted as a UTC string. This is the time the user authenticated (signed in) and not the time the token was refreshed.

                                                                                                                                                                                                                                                                                        property claims

                                                                                                                                                                                                                                                                                        claims: {
                                                                                                                                                                                                                                                                                        [key: string]: any;
                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                        • The entire payload claims of the ID token including the standard reserved claims as well as the custom claims.

                                                                                                                                                                                                                                                                                        property expirationTime

                                                                                                                                                                                                                                                                                        expirationTime: string;
                                                                                                                                                                                                                                                                                        • The ID token expiration time formatted as a UTC string.

                                                                                                                                                                                                                                                                                        property issuedAtTime

                                                                                                                                                                                                                                                                                        issuedAtTime: string;
                                                                                                                                                                                                                                                                                        • The ID token issued at time formatted as a UTC string.

                                                                                                                                                                                                                                                                                        property signInProvider

                                                                                                                                                                                                                                                                                        signInProvider: string | null;
                                                                                                                                                                                                                                                                                        • The sign-in provider through which the ID token was obtained (anonymous, custom, phone, password, etc). Note, this does not map to provider IDs.

                                                                                                                                                                                                                                                                                        property signInSecondFactor

                                                                                                                                                                                                                                                                                        signInSecondFactor: string | null;
                                                                                                                                                                                                                                                                                        • The type of second factor associated with this session, provided the user was multi-factor authenticated (eg. phone, etc).

                                                                                                                                                                                                                                                                                        property token

                                                                                                                                                                                                                                                                                        token: string;
                                                                                                                                                                                                                                                                                        • The Firebase Auth ID token JWT string.

                                                                                                                                                                                                                                                                                        interface MultiFactorError

                                                                                                                                                                                                                                                                                        interface MultiFactorError extends firebase.auth.AuthError {}
                                                                                                                                                                                                                                                                                        • The error thrown when the user needs to provide a second factor to sign in successfully. The error code for this error is auth/multi-factor-auth-required. This error provides a firebase.auth.MultiFactorResolver object, which you can use to get the second sign-in factor from the user.

                                                                                                                                                                                                                                                                                          Example 1

                                                                                                                                                                                                                                                                                          firebase.auth().signInWithEmailAndPassword()
                                                                                                                                                                                                                                                                                          .then(function(result) {
                                                                                                                                                                                                                                                                                          // User signed in. No 2nd factor challenge is needed.
                                                                                                                                                                                                                                                                                          })
                                                                                                                                                                                                                                                                                          .catch(function(error) {
                                                                                                                                                                                                                                                                                          if (error.code == 'auth/multi-factor-auth-required') {
                                                                                                                                                                                                                                                                                          var resolver = error.resolver;
                                                                                                                                                                                                                                                                                          var multiFactorHints = resolver.hints;
                                                                                                                                                                                                                                                                                          } else {
                                                                                                                                                                                                                                                                                          // Handle other errors.
                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                          });
                                                                                                                                                                                                                                                                                          resolver.resolveSignIn(multiFactorAssertion)
                                                                                                                                                                                                                                                                                          .then(function(userCredential) {
                                                                                                                                                                                                                                                                                          // User signed in.
                                                                                                                                                                                                                                                                                          });

                                                                                                                                                                                                                                                                                        property resolver

                                                                                                                                                                                                                                                                                        resolver: firebase.auth.MultiFactorResolver;
                                                                                                                                                                                                                                                                                        • The multi-factor resolver to complete second factor sign-in.

                                                                                                                                                                                                                                                                                        interface MultiFactorInfo

                                                                                                                                                                                                                                                                                        interface MultiFactorInfo {}
                                                                                                                                                                                                                                                                                        • A structure containing the information of a second factor entity.

                                                                                                                                                                                                                                                                                        property displayName

                                                                                                                                                                                                                                                                                        displayName?: string | null;
                                                                                                                                                                                                                                                                                        • The user friendly name of the current second factor.

                                                                                                                                                                                                                                                                                        property enrollmentTime

                                                                                                                                                                                                                                                                                        enrollmentTime: string;
                                                                                                                                                                                                                                                                                        • The enrollment date of the second factor formatted as a UTC string.

                                                                                                                                                                                                                                                                                        property factorId

                                                                                                                                                                                                                                                                                        factorId: string;
                                                                                                                                                                                                                                                                                        • The identifier of the second factor.

                                                                                                                                                                                                                                                                                        property uid

                                                                                                                                                                                                                                                                                        uid: string;
                                                                                                                                                                                                                                                                                        • The multi-factor enrollment ID.

                                                                                                                                                                                                                                                                                        interface OAuthCredentialOptions

                                                                                                                                                                                                                                                                                        interface OAuthCredentialOptions {}

                                                                                                                                                                                                                                                                                        property accessToken

                                                                                                                                                                                                                                                                                        accessToken?: string;
                                                                                                                                                                                                                                                                                        • The OAuth access token used to initialize the OAuthCredential.

                                                                                                                                                                                                                                                                                        property idToken

                                                                                                                                                                                                                                                                                        idToken?: string;
                                                                                                                                                                                                                                                                                        • The OAuth ID token used to initialize the OAuthCredential.

                                                                                                                                                                                                                                                                                        property rawNonce

                                                                                                                                                                                                                                                                                        rawNonce?: string;
                                                                                                                                                                                                                                                                                        • The raw nonce associated with the ID token. It is required when an ID token with a nonce field is provided. The SHA-256 hash of the raw nonce must match the nonce field in the ID token.

                                                                                                                                                                                                                                                                                        interface PhoneMultiFactorEnrollInfoOptions

                                                                                                                                                                                                                                                                                        interface PhoneMultiFactorEnrollInfoOptions {}
                                                                                                                                                                                                                                                                                        • The phone info options for multi-factor enrollment. Phone number and multi-factor session are required.

                                                                                                                                                                                                                                                                                        property phoneNumber

                                                                                                                                                                                                                                                                                        phoneNumber: string;

                                                                                                                                                                                                                                                                                          property session

                                                                                                                                                                                                                                                                                          session: firebase.auth.MultiFactorSession;

                                                                                                                                                                                                                                                                                            interface PhoneMultiFactorInfo

                                                                                                                                                                                                                                                                                            interface PhoneMultiFactorInfo extends firebase.auth.MultiFactorInfo {}

                                                                                                                                                                                                                                                                                            property phoneNumber

                                                                                                                                                                                                                                                                                            phoneNumber: string;
                                                                                                                                                                                                                                                                                            • The phone number associated with the current second factor.

                                                                                                                                                                                                                                                                                            interface PhoneMultiFactorSignInInfoOptions

                                                                                                                                                                                                                                                                                            interface PhoneMultiFactorSignInInfoOptions {}
                                                                                                                                                                                                                                                                                            • The phone info options for multi-factor sign-in. Either multi-factor hint or multi-factor UID and multi-factor session are required.

                                                                                                                                                                                                                                                                                            property multiFactorHint

                                                                                                                                                                                                                                                                                            multiFactorHint?: firebase.auth.MultiFactorInfo;

                                                                                                                                                                                                                                                                                              property multiFactorUid

                                                                                                                                                                                                                                                                                              multiFactorUid?: string;

                                                                                                                                                                                                                                                                                                property session

                                                                                                                                                                                                                                                                                                session: firebase.auth.MultiFactorSession;

                                                                                                                                                                                                                                                                                                  interface PhoneSingleFactorInfoOptions

                                                                                                                                                                                                                                                                                                  interface PhoneSingleFactorInfoOptions {}
                                                                                                                                                                                                                                                                                                  • The phone info options for single-factor sign-in. Only phone number is required.

                                                                                                                                                                                                                                                                                                  property phoneNumber

                                                                                                                                                                                                                                                                                                  phoneNumber: string;

                                                                                                                                                                                                                                                                                                    interface UserMetadata

                                                                                                                                                                                                                                                                                                    interface UserMetadata {}
                                                                                                                                                                                                                                                                                                    • Interface representing a user's metadata.

                                                                                                                                                                                                                                                                                                    property creationTime

                                                                                                                                                                                                                                                                                                    creationTime?: string;

                                                                                                                                                                                                                                                                                                      property lastSignInTime

                                                                                                                                                                                                                                                                                                      lastSignInTime?: string;

                                                                                                                                                                                                                                                                                                        type ActionCodeSettings

                                                                                                                                                                                                                                                                                                        type ActionCodeSettings = {
                                                                                                                                                                                                                                                                                                        android?: {
                                                                                                                                                                                                                                                                                                        installApp?: boolean;
                                                                                                                                                                                                                                                                                                        minimumVersion?: string;
                                                                                                                                                                                                                                                                                                        packageName: string;
                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                        handleCodeInApp?: boolean;
                                                                                                                                                                                                                                                                                                        iOS?: { bundleId: string };
                                                                                                                                                                                                                                                                                                        url: string;
                                                                                                                                                                                                                                                                                                        dynamicLinkDomain?: string;
                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                        • This is the interface that defines the required continue/state URL with optional Android and iOS bundle identifiers. The action code setting fields are: url: Sets the link continue/state URL, which has different meanings in different contexts: When the link is handled in the web action widgets, this is the deep link in the continueUrl query parameter. When the link is handled in the app directly, this is the continueUrl query parameter in the deep link of the Dynamic Link. iOS: Sets the iOS bundle ID. This will try to open the link in an iOS app if it is installed. android: Sets the Android package name. This will try to open the link in an android app if it is installed. If installApp is passed, it specifies whether to install the Android app if the device supports it and the app is not already installed. If this field is provided without a packageName, an error is thrown explaining that the packageName must be provided in conjunction with this field. If minimumVersion is specified, and an older version of the app is installed, the user is taken to the Play Store to upgrade the app. handleCodeInApp: The default is false. When set to true, the action code link will be be sent as a Universal Link or Android App Link and will be opened by the app if installed. In the false case, the code will be sent to the web widget first and then on continue will redirect to the app if installed.

                                                                                                                                                                                                                                                                                                        type AdditionalUserInfo

                                                                                                                                                                                                                                                                                                        type AdditionalUserInfo = {
                                                                                                                                                                                                                                                                                                        isNewUser: boolean;
                                                                                                                                                                                                                                                                                                        profile: Object | null;
                                                                                                                                                                                                                                                                                                        providerId: string;
                                                                                                                                                                                                                                                                                                        username?: string | null;
                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                        • A structure containing additional user information from a federated identity provider.

                                                                                                                                                                                                                                                                                                        type PhoneInfoOptions

                                                                                                                                                                                                                                                                                                        type PhoneInfoOptions =
                                                                                                                                                                                                                                                                                                        | firebase.auth.PhoneSingleFactorInfoOptions
                                                                                                                                                                                                                                                                                                        | firebase.auth.PhoneMultiFactorEnrollInfoOptions
                                                                                                                                                                                                                                                                                                        | firebase.auth.PhoneMultiFactorSignInInfoOptions;
                                                                                                                                                                                                                                                                                                        • The information required to verify the ownership of a phone number. The information that's required depends on whether you are doing single-factor sign-in, multi-factor enrollment or multi-factor sign-in.

                                                                                                                                                                                                                                                                                                        type UserCredential

                                                                                                                                                                                                                                                                                                        type UserCredential = {
                                                                                                                                                                                                                                                                                                        additionalUserInfo?: firebase.auth.AdditionalUserInfo | null;
                                                                                                                                                                                                                                                                                                        credential: firebase.auth.AuthCredential | null;
                                                                                                                                                                                                                                                                                                        operationType?: string | null;
                                                                                                                                                                                                                                                                                                        user: firebase.User | null;
                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                        • A structure containing a User, an AuthCredential, the operationType, and any additional user information that was returned from the identity provider. operationType could be 'signIn' for a sign-in operation, 'link' for a linking operation and 'reauthenticate' for a reauthentication operation.

                                                                                                                                                                                                                                                                                                        namespace firebase.auth.ActionCodeInfo

                                                                                                                                                                                                                                                                                                        namespace firebase.auth.ActionCodeInfo {}

                                                                                                                                                                                                                                                                                                          variable Operation

                                                                                                                                                                                                                                                                                                          var Operation: {
                                                                                                                                                                                                                                                                                                          EMAIL_SIGNIN: string;
                                                                                                                                                                                                                                                                                                          PASSWORD_RESET: string;
                                                                                                                                                                                                                                                                                                          RECOVER_EMAIL: string;
                                                                                                                                                                                                                                                                                                          REVERT_SECOND_FACTOR_ADDITION: string;
                                                                                                                                                                                                                                                                                                          VERIFY_AND_CHANGE_EMAIL: string;
                                                                                                                                                                                                                                                                                                          VERIFY_EMAIL: string;
                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                          • An enumeration of the possible email action types.

                                                                                                                                                                                                                                                                                                          type Operation

                                                                                                                                                                                                                                                                                                          type Operation = string;

                                                                                                                                                                                                                                                                                                            namespace firebase.auth.Auth

                                                                                                                                                                                                                                                                                                            namespace firebase.auth.Auth {}

                                                                                                                                                                                                                                                                                                              variable Persistence

                                                                                                                                                                                                                                                                                                              var Persistence: { LOCAL: string; NONE: string; SESSION: string };
                                                                                                                                                                                                                                                                                                              • An enumeration of the possible persistence mechanism types.

                                                                                                                                                                                                                                                                                                              type Persistence

                                                                                                                                                                                                                                                                                                              type Persistence = string;

                                                                                                                                                                                                                                                                                                                namespace firebase.database

                                                                                                                                                                                                                                                                                                                namespace firebase.database {}

                                                                                                                                                                                                                                                                                                                  function enableLogging

                                                                                                                                                                                                                                                                                                                  enableLogging: (
                                                                                                                                                                                                                                                                                                                  logger?: boolean | ((a: string) => any),
                                                                                                                                                                                                                                                                                                                  persistent?: boolean
                                                                                                                                                                                                                                                                                                                  ) => any;
                                                                                                                                                                                                                                                                                                                  • Logs debugging information to the console.

                                                                                                                                                                                                                                                                                                                    Parameter logger

                                                                                                                                                                                                                                                                                                                    Enables logging if true; disables logging if false. You can also provide a custom logger function to control how things get logged.

                                                                                                                                                                                                                                                                                                                    Parameter persistent

                                                                                                                                                                                                                                                                                                                    Remembers the logging state between page refreshes if true.

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    // Enable logging
                                                                                                                                                                                                                                                                                                                    firebase.database.enableLogging(true);

                                                                                                                                                                                                                                                                                                                    Example 2

                                                                                                                                                                                                                                                                                                                    // Disable logging
                                                                                                                                                                                                                                                                                                                    firebase.database.enableLogging(false);

                                                                                                                                                                                                                                                                                                                    Example 3

                                                                                                                                                                                                                                                                                                                    // Enable logging across page refreshes
                                                                                                                                                                                                                                                                                                                    firebase.database.enableLogging(true, true);

                                                                                                                                                                                                                                                                                                                    Example 4

                                                                                                                                                                                                                                                                                                                    // Provide custom logger which prefixes log statements with "[FIREBASE]"
                                                                                                                                                                                                                                                                                                                    firebase.database.enableLogging(function(message) {
                                                                                                                                                                                                                                                                                                                    console.log("[FIREBASE]", message);
                                                                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                                                                  interface Database

                                                                                                                                                                                                                                                                                                                  interface Database {}
                                                                                                                                                                                                                                                                                                                  • The Firebase Database service interface.

                                                                                                                                                                                                                                                                                                                    Do not call this constructor directly. Instead, use .

                                                                                                                                                                                                                                                                                                                    See for a full guide on how to use the Firebase Database service.

                                                                                                                                                                                                                                                                                                                  property app

                                                                                                                                                                                                                                                                                                                  app: firebase.app.App;
                                                                                                                                                                                                                                                                                                                  • The associated with the Database service instance.

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    var app = database.app;

                                                                                                                                                                                                                                                                                                                  property INTERNAL

                                                                                                                                                                                                                                                                                                                  INTERNAL: {
                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                  * Force the use of WebSockets instead of long polling.
                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                  forceWebSockets: () => void;
                                                                                                                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                                                                                                                  * Force the use of long polling instead of WebSockets. This will be ignored if the WebSocket protocol is used in `databaseURL`.
                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                  forceLongPolling: () => void;
                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                  • Additional methods for debugging and special cases.

                                                                                                                                                                                                                                                                                                                  method goOffline

                                                                                                                                                                                                                                                                                                                  goOffline: () => any;
                                                                                                                                                                                                                                                                                                                  • Disconnects from the server (all Database operations will be completed offline).

                                                                                                                                                                                                                                                                                                                    The client automatically maintains a persistent connection to the Database server, which will remain active indefinitely and reconnect when disconnected. However, the goOffline() and goOnline() methods may be used to control the client connection in cases where a persistent connection is undesirable.

                                                                                                                                                                                                                                                                                                                    While offline, the client will no longer receive data updates from the Database. However, all Database operations performed locally will continue to immediately fire events, allowing your application to continue behaving normally. Additionally, each operation performed locally will automatically be queued and retried upon reconnection to the Database server.

                                                                                                                                                                                                                                                                                                                    To reconnect to the Database and begin receiving remote events, see goOnline().

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    firebase.database().goOffline();

                                                                                                                                                                                                                                                                                                                  method goOnline

                                                                                                                                                                                                                                                                                                                  goOnline: () => any;
                                                                                                                                                                                                                                                                                                                  • Reconnects to the server and synchronizes the offline Database state with the server state.

                                                                                                                                                                                                                                                                                                                    This method should be used after disabling the active connection with goOffline(). Once reconnected, the client will transmit the proper data and fire the appropriate events so that your client "catches up" automatically.

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    firebase.database().goOnline();

                                                                                                                                                                                                                                                                                                                  method ref

                                                                                                                                                                                                                                                                                                                  ref: (path?: string) => Reference;
                                                                                                                                                                                                                                                                                                                  • Returns a Reference representing the location in the Database corresponding to the provided path. If no path is provided, the Reference will point to the root of the Database.

                                                                                                                                                                                                                                                                                                                    Parameter path

                                                                                                                                                                                                                                                                                                                    Optional path representing the location the returned Reference will point. If not provided, the returned Reference will point to the root of the Database. If a path is provided, a Reference pointing to the provided path. Otherwise, a Reference pointing to the root of the Database.

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    // Get a reference to the root of the Database
                                                                                                                                                                                                                                                                                                                    var rootRef = firebase.database().ref();

                                                                                                                                                                                                                                                                                                                    Example 2

                                                                                                                                                                                                                                                                                                                    // Get a reference to the /users/ada node
                                                                                                                                                                                                                                                                                                                    var adaRef = firebase.database().ref("users/ada");
                                                                                                                                                                                                                                                                                                                    // The above is shorthand for the following operations:
                                                                                                                                                                                                                                                                                                                    //var rootRef = firebase.database().ref();
                                                                                                                                                                                                                                                                                                                    //var adaRef = rootRef.child("users/ada");

                                                                                                                                                                                                                                                                                                                  method refFromURL

                                                                                                                                                                                                                                                                                                                  refFromURL: (url: string) => Reference;
                                                                                                                                                                                                                                                                                                                  • Returns a Reference representing the location in the Database corresponding to the provided Firebase URL.

                                                                                                                                                                                                                                                                                                                    An exception is thrown if the URL is not a valid Firebase Database URL or it has a different domain than the current Database instance.

                                                                                                                                                                                                                                                                                                                    Note that all query parameters (orderBy, limitToLast, etc.) are ignored and are not applied to the returned Reference.

                                                                                                                                                                                                                                                                                                                    Parameter url

                                                                                                                                                                                                                                                                                                                    The Firebase URL at which the returned Reference will point. A Reference pointing to the provided Firebase URL.

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    // Get a reference to the root of the Database
                                                                                                                                                                                                                                                                                                                    var rootRef = firebase.database().ref("https://<DATABASE_NAME>.firebaseio.com");

                                                                                                                                                                                                                                                                                                                    Example 2

                                                                                                                                                                                                                                                                                                                    // Get a reference to the /users/ada node
                                                                                                                                                                                                                                                                                                                    var adaRef = firebase.database().ref("https://<DATABASE_NAME>.firebaseio.com/users/ada");

                                                                                                                                                                                                                                                                                                                  method useEmulator

                                                                                                                                                                                                                                                                                                                  useEmulator: (
                                                                                                                                                                                                                                                                                                                  host: string,
                                                                                                                                                                                                                                                                                                                  port: number,
                                                                                                                                                                                                                                                                                                                  options?: { mockUserToken?: EmulatorMockTokenOptions | string }
                                                                                                                                                                                                                                                                                                                  ) => void;
                                                                                                                                                                                                                                                                                                                  • Modify this instance to communicate with the Realtime Database emulator.

                                                                                                                                                                                                                                                                                                                    Note: This method must be called before performing any other operation.

                                                                                                                                                                                                                                                                                                                    Parameter host

                                                                                                                                                                                                                                                                                                                    the emulator host (ex: localhost)

                                                                                                                                                                                                                                                                                                                    Parameter port

                                                                                                                                                                                                                                                                                                                    the emulator port (ex: 8080)

                                                                                                                                                                                                                                                                                                                    Parameter

                                                                                                                                                                                                                                                                                                                    options.mockUserToken the mock auth token to use for unit testing Security Rules

                                                                                                                                                                                                                                                                                                                  interface DataSnapshot

                                                                                                                                                                                                                                                                                                                  interface DataSnapshot {}
                                                                                                                                                                                                                                                                                                                  • A DataSnapshot contains data from a Database location.

                                                                                                                                                                                                                                                                                                                    Any time you read data from the Database, you receive the data as a DataSnapshot. A DataSnapshot is passed to the event callbacks you attach with on() or once(). You can extract the contents of the snapshot as a JavaScript object by calling the val() method. Alternatively, you can traverse into the snapshot by calling child() to return child snapshots (which you could then call val() on).

                                                                                                                                                                                                                                                                                                                    A DataSnapshot is an efficiently generated, immutable copy of the data at a Database location. It cannot be modified and will never change (to modify data, you always call the set() method on a Reference directly).

                                                                                                                                                                                                                                                                                                                  property key

                                                                                                                                                                                                                                                                                                                  key: string | null;
                                                                                                                                                                                                                                                                                                                  • The key (last part of the path) of the location of this DataSnapshot.

                                                                                                                                                                                                                                                                                                                    The last token in a Database location is considered its key. For example, "ada" is the key for the /users/ada/ node. Accessing the key on any DataSnapshot will return the key for the location that generated it. However, accessing the key on the root URL of a Database will return null.

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    // Assume we have the following data in the Database:
                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                    "name": {
                                                                                                                                                                                                                                                                                                                    "first": "Ada",
                                                                                                                                                                                                                                                                                                                    "last": "Lovelace"
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    var ref = firebase.database().ref("users/ada");
                                                                                                                                                                                                                                                                                                                    ref.once("value")
                                                                                                                                                                                                                                                                                                                    .then(function(snapshot) {
                                                                                                                                                                                                                                                                                                                    var key = snapshot.key; // "ada"
                                                                                                                                                                                                                                                                                                                    var childKey = snapshot.child("name/last").key; // "last"
                                                                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                                                                    Example 2

                                                                                                                                                                                                                                                                                                                    var rootRef = firebase.database().ref();
                                                                                                                                                                                                                                                                                                                    rootRef.once("value")
                                                                                                                                                                                                                                                                                                                    .then(function(snapshot) {
                                                                                                                                                                                                                                                                                                                    var key = snapshot.key; // null
                                                                                                                                                                                                                                                                                                                    var childKey = snapshot.child("users/ada").key; // "ada"
                                                                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                                                                  property ref

                                                                                                                                                                                                                                                                                                                  ref: firebase.database.Reference;
                                                                                                                                                                                                                                                                                                                  • The Reference for the location that generated this DataSnapshot.

                                                                                                                                                                                                                                                                                                                  method child

                                                                                                                                                                                                                                                                                                                  child: (path: string) => DataSnapshot;
                                                                                                                                                                                                                                                                                                                  • Gets another DataSnapshot for the location at the specified relative path.

                                                                                                                                                                                                                                                                                                                    Passing a relative path to the child() method of a DataSnapshot returns another DataSnapshot for the location at the specified relative path. The relative path can either be a simple child name (for example, "ada") or a deeper, slash-separated path (for example, "ada/name/first"). If the child location has no data, an empty DataSnapshot (that is, a DataSnapshot whose value is null) is returned.

                                                                                                                                                                                                                                                                                                                    Parameter path

                                                                                                                                                                                                                                                                                                                    A relative path to the location of child data.

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    // Assume we have the following data in the Database:
                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                    "name": {
                                                                                                                                                                                                                                                                                                                    "first": "Ada",
                                                                                                                                                                                                                                                                                                                    "last": "Lovelace"
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    // Test for the existence of certain keys within a DataSnapshot
                                                                                                                                                                                                                                                                                                                    var ref = firebase.database().ref("users/ada");
                                                                                                                                                                                                                                                                                                                    ref.once("value")
                                                                                                                                                                                                                                                                                                                    .then(function(snapshot) {
                                                                                                                                                                                                                                                                                                                    var name = snapshot.child("name").val(); // {first:"Ada",last:"Lovelace"}
                                                                                                                                                                                                                                                                                                                    var firstName = snapshot.child("name/first").val(); // "Ada"
                                                                                                                                                                                                                                                                                                                    var lastName = snapshot.child("name").child("last").val(); // "Lovelace"
                                                                                                                                                                                                                                                                                                                    var age = snapshot.child("age").val(); // null
                                                                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                                                                  method exists

                                                                                                                                                                                                                                                                                                                  exists: () => boolean;
                                                                                                                                                                                                                                                                                                                  • Returns true if this DataSnapshot contains any data. It is slightly more efficient than using snapshot.val() !== null.

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    // Assume we have the following data in the Database:
                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                    "name": {
                                                                                                                                                                                                                                                                                                                    "first": "Ada",
                                                                                                                                                                                                                                                                                                                    "last": "Lovelace"
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    // Test for the existence of certain keys within a DataSnapshot
                                                                                                                                                                                                                                                                                                                    var ref = firebase.database().ref("users/ada");
                                                                                                                                                                                                                                                                                                                    ref.once("value")
                                                                                                                                                                                                                                                                                                                    .then(function(snapshot) {
                                                                                                                                                                                                                                                                                                                    var a = snapshot.exists(); // true
                                                                                                                                                                                                                                                                                                                    var b = snapshot.child("name").exists(); // true
                                                                                                                                                                                                                                                                                                                    var c = snapshot.child("name/first").exists(); // true
                                                                                                                                                                                                                                                                                                                    var d = snapshot.child("name/middle").exists(); // false
                                                                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                                                                  method exportVal

                                                                                                                                                                                                                                                                                                                  exportVal: () => any;
                                                                                                                                                                                                                                                                                                                  • Exports the entire contents of the DataSnapshot as a JavaScript object.

                                                                                                                                                                                                                                                                                                                    The exportVal() method is similar to val(), except priority information is included (if available), making it suitable for backing up your data.

                                                                                                                                                                                                                                                                                                                    The DataSnapshot's contents as a JavaScript value (Object, Array, string, number, boolean, or null).

                                                                                                                                                                                                                                                                                                                  method forEach

                                                                                                                                                                                                                                                                                                                  forEach: (action: (a: IteratedDataSnapshot) => boolean | void) => boolean;
                                                                                                                                                                                                                                                                                                                  • Enumerates the top-level children in the DataSnapshot.

                                                                                                                                                                                                                                                                                                                    Because of the way JavaScript objects work, the ordering of data in the JavaScript object returned by val() is not guaranteed to match the ordering on the server nor the ordering of child_added events. That is where forEach() comes in handy. It guarantees the children of a DataSnapshot will be iterated in their query order.

                                                                                                                                                                                                                                                                                                                    If no explicit orderBy*() method is used, results are returned ordered by key (unless priorities are used, in which case, results are returned by priority).

                                                                                                                                                                                                                                                                                                                    Parameter action

                                                                                                                                                                                                                                                                                                                    A function that will be called for each child DataSnapshot. The callback can return true to cancel further enumeration. true if enumeration was canceled due to your callback returning true.

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    // Assume we have the following data in the Database:
                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                    "users": {
                                                                                                                                                                                                                                                                                                                    "ada": {
                                                                                                                                                                                                                                                                                                                    "first": "Ada",
                                                                                                                                                                                                                                                                                                                    "last": "Lovelace"
                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                    "alan": {
                                                                                                                                                                                                                                                                                                                    "first": "Alan",
                                                                                                                                                                                                                                                                                                                    "last": "Turing"
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    // Loop through users in order with the forEach() method. The callback
                                                                                                                                                                                                                                                                                                                    // provided to forEach() will be called synchronously with a DataSnapshot
                                                                                                                                                                                                                                                                                                                    // for each child:
                                                                                                                                                                                                                                                                                                                    var query = firebase.database().ref("users").orderByKey();
                                                                                                                                                                                                                                                                                                                    query.once("value")
                                                                                                                                                                                                                                                                                                                    .then(function(snapshot) {
                                                                                                                                                                                                                                                                                                                    snapshot.forEach(function(childSnapshot) {
                                                                                                                                                                                                                                                                                                                    // key will be "ada" the first time and "alan" the second time
                                                                                                                                                                                                                                                                                                                    var key = childSnapshot.key;
                                                                                                                                                                                                                                                                                                                    // childData will be the actual contents of the child
                                                                                                                                                                                                                                                                                                                    var childData = childSnapshot.val();
                                                                                                                                                                                                                                                                                                                    });
                                                                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                                                                    Example 2

                                                                                                                                                                                                                                                                                                                    // You can cancel the enumeration at any point by having your callback
                                                                                                                                                                                                                                                                                                                    // function return true. For example, the following code sample will only
                                                                                                                                                                                                                                                                                                                    // fire the callback function one time:
                                                                                                                                                                                                                                                                                                                    var query = firebase.database().ref("users").orderByKey();
                                                                                                                                                                                                                                                                                                                    query.once("value")
                                                                                                                                                                                                                                                                                                                    .then(function(snapshot) {
                                                                                                                                                                                                                                                                                                                    snapshot.forEach(function(childSnapshot) {
                                                                                                                                                                                                                                                                                                                    var key = childSnapshot.key; // "ada"
                                                                                                                                                                                                                                                                                                                    // Cancel enumeration
                                                                                                                                                                                                                                                                                                                    return true;
                                                                                                                                                                                                                                                                                                                    });
                                                                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                                                                  method getPriority

                                                                                                                                                                                                                                                                                                                  getPriority: () => string | number | null;
                                                                                                                                                                                                                                                                                                                  • Gets the priority value of the data in this DataSnapshot.

                                                                                                                                                                                                                                                                                                                    Applications need not use priority but can order collections by ordinary properties (see ).

                                                                                                                                                                                                                                                                                                                  method hasChild

                                                                                                                                                                                                                                                                                                                  hasChild: (path: string) => boolean;
                                                                                                                                                                                                                                                                                                                  • Returns true if the specified child path has (non-null) data.

                                                                                                                                                                                                                                                                                                                    Parameter path

                                                                                                                                                                                                                                                                                                                    A relative path to the location of a potential child. true if data exists at the specified child path; else false.

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    // Assume we have the following data in the Database:
                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                    "name": {
                                                                                                                                                                                                                                                                                                                    "first": "Ada",
                                                                                                                                                                                                                                                                                                                    "last": "Lovelace"
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    // Determine which child keys in DataSnapshot have data.
                                                                                                                                                                                                                                                                                                                    var ref = firebase.database().ref("users/ada");
                                                                                                                                                                                                                                                                                                                    ref.once("value")
                                                                                                                                                                                                                                                                                                                    .then(function(snapshot) {
                                                                                                                                                                                                                                                                                                                    var hasName = snapshot.hasChild("name"); // true
                                                                                                                                                                                                                                                                                                                    var hasAge = snapshot.hasChild("age"); // false
                                                                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                                                                  method hasChildren

                                                                                                                                                                                                                                                                                                                  hasChildren: () => boolean;
                                                                                                                                                                                                                                                                                                                  • Returns whether or not the DataSnapshot has any non-null child properties.

                                                                                                                                                                                                                                                                                                                    You can use hasChildren() to determine if a DataSnapshot has any children. If it does, you can enumerate them using forEach(). If it doesn't, then either this snapshot contains a primitive value (which can be retrieved with val()) or it is empty (in which case, val() will return null).

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    // Assume we have the following data in the Database:
                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                    "name": {
                                                                                                                                                                                                                                                                                                                    "first": "Ada",
                                                                                                                                                                                                                                                                                                                    "last": "Lovelace"
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    var ref = firebase.database().ref("users/ada");
                                                                                                                                                                                                                                                                                                                    ref.once("value")
                                                                                                                                                                                                                                                                                                                    .then(function(snapshot) {
                                                                                                                                                                                                                                                                                                                    var a = snapshot.hasChildren(); // true
                                                                                                                                                                                                                                                                                                                    var b = snapshot.child("name").hasChildren(); // true
                                                                                                                                                                                                                                                                                                                    var c = snapshot.child("name/first").hasChildren(); // false
                                                                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                                                                    true if this snapshot has any children; else false.

                                                                                                                                                                                                                                                                                                                  method numChildren

                                                                                                                                                                                                                                                                                                                  numChildren: () => number;
                                                                                                                                                                                                                                                                                                                  • Returns the number of child properties of this DataSnapshot.

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    // Assume we have the following data in the Database:
                                                                                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                                                                                    "name": {
                                                                                                                                                                                                                                                                                                                    "first": "Ada",
                                                                                                                                                                                                                                                                                                                    "last": "Lovelace"
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    var ref = firebase.database().ref("users/ada");
                                                                                                                                                                                                                                                                                                                    ref.once("value")
                                                                                                                                                                                                                                                                                                                    .then(function(snapshot) {
                                                                                                                                                                                                                                                                                                                    var a = snapshot.numChildren(); // 1 ("name")
                                                                                                                                                                                                                                                                                                                    var b = snapshot.child("name").numChildren(); // 2 ("first", "last")
                                                                                                                                                                                                                                                                                                                    var c = snapshot.child("name/first").numChildren(); // 0
                                                                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                                                                  method toJSON

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

                                                                                                                                                                                                                                                                                                                  method val

                                                                                                                                                                                                                                                                                                                  val: () => any;
                                                                                                                                                                                                                                                                                                                  • Extracts a JavaScript value from a DataSnapshot.

                                                                                                                                                                                                                                                                                                                    Depending on the data in a DataSnapshot, the val() method may return a scalar type (string, number, or boolean), an array, or an object. It may also return null, indicating that the DataSnapshot is empty (contains no data).

                                                                                                                                                                                                                                                                                                                    Example 1

                                                                                                                                                                                                                                                                                                                    // Write and then read back a string from the Database.
                                                                                                                                                                                                                                                                                                                    ref.set("hello")
                                                                                                                                                                                                                                                                                                                    .then(function() {
                                                                                                                                                                                                                                                                                                                    return ref.once("value");
                                                                                                                                                                                                                                                                                                                    })
                                                                                                                                                                                                                                                                                                                    .then(function(snapshot) {
                                                                                                                                                                                                                                                                                                                    var data = snapshot.val(); // data === "hello"
                                                                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                                                                    Example 2

                                                                                                                                                                                                                                                                                                                    // Write and then read back a JavaScript object from the Database.
                                                                                                                                                                                                                                                                                                                    ref.set({ name: "Ada", age: 36 })
                                                                                                                                                                                                                                                                                                                    .then(function() {
                                                                                                                                                                                                                                                                                                                    return ref.once("value");
                                                                                                                                                                                                                                                                                                                    })
                                                                                                                                                                                                                                                                                                                    .then(function(snapshot) {
                                                                                                                                                                                                                                                                                                                    var data = snapshot.val();
                                                                                                                                                                                                                                                                                                                    // data is { "name": "Ada", "age": 36 }
                                                                                                                                                                                                                                                                                                                    // data.name === "Ada"
                                                                                                                                                                                                                                                                                                                    // data.age === 36
                                                                                                                                                                                                                                                                                                                    });

                                                                                                                                                                                                                                                                                                                    The DataSnapshot's contents as a JavaScript value (Object, Array, string, number, boolean, or null).

                                                                                                                                                                                                                                                                                                                  interface IteratedDataSnapshot

                                                                                                                                                                                                                                                                                                                  interface IteratedDataSnapshot extends DataSnapshot {}

                                                                                                                                                                                                                                                                                                                    property key

                                                                                                                                                                                                                                                                                                                    key: string;

                                                                                                                                                                                                                                                                                                                      interface OnDisconnect

                                                                                                                                                                                                                                                                                                                      interface OnDisconnect {}
                                                                                                                                                                                                                                                                                                                      • The onDisconnect class allows you to write or clear data when your client disconnects from the Database server. These updates occur whether your client disconnects cleanly or not, so you can rely on them to clean up data even if a connection is dropped or a client crashes.

                                                                                                                                                                                                                                                                                                                        The onDisconnect class is most commonly used to manage presence in applications where it is useful to detect how many clients are connected and when other clients disconnect. See for more information.

                                                                                                                                                                                                                                                                                                                        To avoid problems when a connection is dropped before the requests can be transferred to the Database server, these functions should be called before writing any data.

                                                                                                                                                                                                                                                                                                                        Note that onDisconnect operations are only triggered once. If you want an operation to occur each time a disconnect occurs, you'll need to re-establish the onDisconnect operations each time you reconnect.

                                                                                                                                                                                                                                                                                                                      method cancel

                                                                                                                                                                                                                                                                                                                      cancel: (onComplete?: (a: Error | null) => any) => Promise<any>;
                                                                                                                                                                                                                                                                                                                      • Cancels all previously queued onDisconnect() set or update events for this location and all children.

                                                                                                                                                                                                                                                                                                                        If a write has been queued for this location via a set() or update() at a parent location, the write at this location will be canceled, though writes to sibling locations will still occur.

                                                                                                                                                                                                                                                                                                                        Parameter onComplete

                                                                                                                                                                                                                                                                                                                        An optional callback function that will be called when synchronization to the server has completed. The callback will be passed a single parameter: null for success, or an Error object indicating a failure. Resolves when synchronization to the server is complete.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        var ref = firebase.database().ref("onlineState");
                                                                                                                                                                                                                                                                                                                        ref.onDisconnect().set(false);
                                                                                                                                                                                                                                                                                                                        // ... sometime later
                                                                                                                                                                                                                                                                                                                        ref.onDisconnect().cancel();

                                                                                                                                                                                                                                                                                                                      method remove

                                                                                                                                                                                                                                                                                                                      remove: (onComplete?: (a: Error | null) => any) => Promise<any>;
                                                                                                                                                                                                                                                                                                                      • Ensures the data at this location is deleted when the client is disconnected (due to closing the browser, navigating to a new page, or network issues).

                                                                                                                                                                                                                                                                                                                        Parameter onComplete

                                                                                                                                                                                                                                                                                                                        An optional callback function that will be called when synchronization to the server has completed. The callback will be passed a single parameter: null for success, or an Error object indicating a failure. Resolves when synchronization to the server is complete.

                                                                                                                                                                                                                                                                                                                      method set

                                                                                                                                                                                                                                                                                                                      set: (value: any, onComplete?: (a: Error | null) => any) => Promise<any>;
                                                                                                                                                                                                                                                                                                                      • Ensures the data at this location is set to the specified value when the client is disconnected (due to closing the browser, navigating to a new page, or network issues).

                                                                                                                                                                                                                                                                                                                        set() is especially useful for implementing "presence" systems, where a value should be changed or cleared when a user disconnects so that they appear "offline" to other users. See for more information.

                                                                                                                                                                                                                                                                                                                        Note that onDisconnect operations are only triggered once. If you want an operation to occur each time a disconnect occurs, you'll need to re-establish the onDisconnect operations each time.

                                                                                                                                                                                                                                                                                                                        Parameter value

                                                                                                                                                                                                                                                                                                                        The value to be written to this location on disconnect (can be an object, array, string, number, boolean, or null).

                                                                                                                                                                                                                                                                                                                        Parameter onComplete

                                                                                                                                                                                                                                                                                                                        An optional callback function that will be called when synchronization to the Database server has completed. The callback will be passed a single parameter: null for success, or an Error object indicating a failure. Resolves when synchronization to the Database is complete.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        var ref = firebase.database().ref("users/ada/status");
                                                                                                                                                                                                                                                                                                                        ref.onDisconnect().set("I disconnected!");

                                                                                                                                                                                                                                                                                                                      method setWithPriority

                                                                                                                                                                                                                                                                                                                      setWithPriority: (
                                                                                                                                                                                                                                                                                                                      value: any,
                                                                                                                                                                                                                                                                                                                      priority: number | string | null,
                                                                                                                                                                                                                                                                                                                      onComplete?: (a: Error | null) => any
                                                                                                                                                                                                                                                                                                                      ) => Promise<any>;
                                                                                                                                                                                                                                                                                                                      • Ensures the data at this location is set to the specified value and priority when the client is disconnected (due to closing the browser, navigating to a new page, or network issues).

                                                                                                                                                                                                                                                                                                                      method update

                                                                                                                                                                                                                                                                                                                      update: (values: Object, onComplete?: (a: Error | null) => any) => Promise<any>;
                                                                                                                                                                                                                                                                                                                      • Writes multiple values at this location when the client is disconnected (due to closing the browser, navigating to a new page, or network issues).

                                                                                                                                                                                                                                                                                                                        The values argument contains multiple property-value pairs that will be written to the Database together. Each child property can either be a simple property (for example, "name") or a relative path (for example, "name/first") from the current location to the data to update.

                                                                                                                                                                                                                                                                                                                        As opposed to the set() method, update() can be use to selectively update only the referenced properties at the current location (instead of replacing all the child properties at the current location).

                                                                                                                                                                                                                                                                                                                        See more examples using the connected version of .

                                                                                                                                                                                                                                                                                                                        Parameter values

                                                                                                                                                                                                                                                                                                                        Object containing multiple values.

                                                                                                                                                                                                                                                                                                                        Parameter onComplete

                                                                                                                                                                                                                                                                                                                        An optional callback function that will be called when synchronization to the server has completed. The callback will be passed a single parameter: null for success, or an Error object indicating a failure. Resolves when synchronization to the Database is complete.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        var ref = firebase.database().ref("users/ada");
                                                                                                                                                                                                                                                                                                                        ref.update({
                                                                                                                                                                                                                                                                                                                        onlineState: true,
                                                                                                                                                                                                                                                                                                                        status: "I'm online."
                                                                                                                                                                                                                                                                                                                        });
                                                                                                                                                                                                                                                                                                                        ref.onDisconnect().update({
                                                                                                                                                                                                                                                                                                                        onlineState: false,
                                                                                                                                                                                                                                                                                                                        status: "I'm offline."
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                      interface Query

                                                                                                                                                                                                                                                                                                                      interface Query {}
                                                                                                                                                                                                                                                                                                                      • A Query sorts and filters the data at a Database location so only a subset of the child data is included. This can be used to order a collection of data by some attribute (for example, height of dinosaurs) as well as to restrict a large list of items (for example, chat messages) down to a number suitable for synchronizing to the client. Queries are created by chaining together one or more of the filter methods defined here.

                                                                                                                                                                                                                                                                                                                        Just as with a Reference, you can receive data from a Query by using the on() method. You will only receive events and DataSnapshots for the subset of the data that matches your query.

                                                                                                                                                                                                                                                                                                                        Read our documentation on for more information.

                                                                                                                                                                                                                                                                                                                      property ref

                                                                                                                                                                                                                                                                                                                      ref: firebase.database.Reference;
                                                                                                                                                                                                                                                                                                                      • Returns a Reference to the Query's location.

                                                                                                                                                                                                                                                                                                                      method endAt

                                                                                                                                                                                                                                                                                                                      endAt: (value: number | string | boolean | null, key?: string) => Query;
                                                                                                                                                                                                                                                                                                                      • Creates a Query with the specified ending point.

                                                                                                                                                                                                                                                                                                                        Using startAt(), startAfter(), endBefore(), endAt() and equalTo() allows you to choose arbitrary starting and ending points for your queries.

                                                                                                                                                                                                                                                                                                                        The ending point is inclusive, so children with exactly the specified value will be included in the query. The optional key argument can be used to further limit the range of the query. If it is specified, then children that have exactly the specified value must also have a key name less than or equal to the specified key.

                                                                                                                                                                                                                                                                                                                        You can read more about endAt() in .

                                                                                                                                                                                                                                                                                                                        Parameter value

                                                                                                                                                                                                                                                                                                                        The value to end at. The argument type depends on which orderBy*() function was used in this query. Specify a value that matches the orderBy*() type. When used in combination with orderByKey(), the value must be a string.

                                                                                                                                                                                                                                                                                                                        Parameter key

                                                                                                                                                                                                                                                                                                                        The child key to end at, among the children with the previously specified priority. This argument is only allowed if ordering by child, value, or priority.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        // Find all dinosaurs whose names come before Pterodactyl lexicographically.
                                                                                                                                                                                                                                                                                                                        // Include Pterodactyl in the result.
                                                                                                                                                                                                                                                                                                                        var ref = firebase.database().ref("dinosaurs");
                                                                                                                                                                                                                                                                                                                        ref.orderByKey().endAt("pterodactyl").on("child_added", function(snapshot) {
                                                                                                                                                                                                                                                                                                                        console.log(snapshot.key);
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                      method endBefore

                                                                                                                                                                                                                                                                                                                      endBefore: (value: number | string | boolean | null, key?: string) => Query;
                                                                                                                                                                                                                                                                                                                      • Creates a Query with the specified ending point (exclusive).

                                                                                                                                                                                                                                                                                                                        Using startAt(), startAfter(), endBefore(), endAt() and equalTo() allows you to choose arbitrary starting and ending points for your queries.

                                                                                                                                                                                                                                                                                                                        The ending point is exclusive. If only a value is provided, children with a value less than the specified value will be included in the query. If a key is specified, then children must have a value less than or equal to the specified value and a a key name less than the specified key.

                                                                                                                                                                                                                                                                                                                        Parameter value

                                                                                                                                                                                                                                                                                                                        The value to end before. The argument type depends on which orderBy*() function was used in this query. Specify a value that matches the orderBy*() type. When used in combination with orderByKey(), the value must be a string.

                                                                                                                                                                                                                                                                                                                        Parameter key

                                                                                                                                                                                                                                                                                                                        The child key to end before, among the children with the previously specified priority. This argument is only allowed if ordering by child, value, or priority.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        ```javascript // Find all dinosaurs whose names come before Pterodactyl lexicographically. // Do not include Pterodactyl in the result. var ref = firebase.database().ref("dinosaurs"); ref.orderByKey().endBefore("pterodactyl").on("child_added", function(snapshot) { console.log(snapshot.key); });

                                                                                                                                                                                                                                                                                                                      method equalTo

                                                                                                                                                                                                                                                                                                                      equalTo: (value: number | string | boolean | null, key?: string) => Query;
                                                                                                                                                                                                                                                                                                                      • Creates a Query that includes children that match the specified value.

                                                                                                                                                                                                                                                                                                                        Using startAt(), startAfter(), endBefore(), endAt() and equalTo() allows you to choose arbitrary starting and ending points for your queries.

                                                                                                                                                                                                                                                                                                                        The optional key argument can be used to further limit the range of the query. If it is specified, then children that have exactly the specified value must also have exactly the specified key as their key name. This can be used to filter result sets with many matches for the same value.

                                                                                                                                                                                                                                                                                                                        You can read more about equalTo() in .

                                                                                                                                                                                                                                                                                                                        Parameter value

                                                                                                                                                                                                                                                                                                                        The value to match for. The argument type depends on which orderBy*() function was used in this query. Specify a value that matches the orderBy*() type. When used in combination with orderByKey(), the value must be a string.

                                                                                                                                                                                                                                                                                                                        Parameter key

                                                                                                                                                                                                                                                                                                                        The child key to start at, among the children with the previously specified priority. This argument is only allowed if ordering by child, value, or priority.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        // Find all dinosaurs whose height is exactly 25 meters.
                                                                                                                                                                                                                                                                                                                        var ref = firebase.database().ref("dinosaurs");
                                                                                                                                                                                                                                                                                                                        ref.orderByChild("height").equalTo(25).on("child_added", function(snapshot) {
                                                                                                                                                                                                                                                                                                                        console.log(snapshot.key);
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                      method get

                                                                                                                                                                                                                                                                                                                      get: () => Promise<DataSnapshot>;
                                                                                                                                                                                                                                                                                                                      • Gets the most up-to-date result for this query.

                                                                                                                                                                                                                                                                                                                        A promise which resolves to the resulting DataSnapshot if a value is available, or rejects if the client is unable to return a value (e.g., if the server is unreachable and there is nothing cached).

                                                                                                                                                                                                                                                                                                                      method isEqual

                                                                                                                                                                                                                                                                                                                      isEqual: (other: Query) => boolean;
                                                                                                                                                                                                                                                                                                                      • Returns whether or not the current and provided queries represent the same location, have the same query parameters, and are from the same instance of firebase.app.App.

                                                                                                                                                                                                                                                                                                                        Two Reference objects are equivalent if they represent the same location and are from the same instance of firebase.app.App.

                                                                                                                                                                                                                                                                                                                        Two Query objects are equivalent if they represent the same location, have the same query parameters, and are from the same instance of firebase.app.App. Equivalent queries share the same sort order, limits, and starting and ending points.

                                                                                                                                                                                                                                                                                                                        Parameter other

                                                                                                                                                                                                                                                                                                                        The query to compare against. Whether or not the current and provided queries are equivalent.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        var rootRef = firebase.database.ref();
                                                                                                                                                                                                                                                                                                                        var usersRef = rootRef.child("users");
                                                                                                                                                                                                                                                                                                                        usersRef.isEqual(rootRef); // false
                                                                                                                                                                                                                                                                                                                        usersRef.isEqual(rootRef.child("users")); // true
                                                                                                                                                                                                                                                                                                                        usersRef.parent.isEqual(rootRef); // true

                                                                                                                                                                                                                                                                                                                        Example 2

                                                                                                                                                                                                                                                                                                                        var rootRef = firebase.database.ref();
                                                                                                                                                                                                                                                                                                                        var usersRef = rootRef.child("users");
                                                                                                                                                                                                                                                                                                                        var usersQuery = usersRef.limitToLast(10);
                                                                                                                                                                                                                                                                                                                        usersQuery.isEqual(usersRef); // false
                                                                                                                                                                                                                                                                                                                        usersQuery.isEqual(usersRef.limitToLast(10)); // true
                                                                                                                                                                                                                                                                                                                        usersQuery.isEqual(rootRef.limitToLast(10)); // false
                                                                                                                                                                                                                                                                                                                        usersQuery.isEqual(usersRef.orderByKey().limitToLast(10)); // false

                                                                                                                                                                                                                                                                                                                      method limitToFirst

                                                                                                                                                                                                                                                                                                                      limitToFirst: (limit: number) => Query;
                                                                                                                                                                                                                                                                                                                      • Generates a new Query limited to the first specific number of children.

                                                                                                                                                                                                                                                                                                                        The limitToFirst() method is used to set a maximum number of children to be synced for a given callback. If we set a limit of 100, we will initially only receive up to 100 child_added events. If we have fewer than 100 messages stored in our Database, a child_added event will fire for each message. However, if we have over 100 messages, we will only receive a child_added event for the first 100 ordered messages. As items change, we will receive child_removed events for each item that drops out of the active list so that the total number stays at 100.

                                                                                                                                                                                                                                                                                                                        You can read more about limitToFirst() in .

                                                                                                                                                                                                                                                                                                                        Parameter limit

                                                                                                                                                                                                                                                                                                                        The maximum number of nodes to include in this query.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        // Find the two shortest dinosaurs.
                                                                                                                                                                                                                                                                                                                        var ref = firebase.database().ref("dinosaurs");
                                                                                                                                                                                                                                                                                                                        ref.orderByChild("height").limitToFirst(2).on("child_added", function(snapshot) {
                                                                                                                                                                                                                                                                                                                        // This will be called exactly two times (unless there are less than two
                                                                                                                                                                                                                                                                                                                        // dinosaurs in the Database).
                                                                                                                                                                                                                                                                                                                        // It will also get fired again if one of the first two dinosaurs is
                                                                                                                                                                                                                                                                                                                        // removed from the data set, as a new dinosaur will now be the second
                                                                                                                                                                                                                                                                                                                        // shortest.
                                                                                                                                                                                                                                                                                                                        console.log(snapshot.key);
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                      method limitToLast

                                                                                                                                                                                                                                                                                                                      limitToLast: (limit: number) => Query;
                                                                                                                                                                                                                                                                                                                      • Generates a new Query object limited to the last specific number of children.

                                                                                                                                                                                                                                                                                                                        The limitToLast() method is used to set a maximum number of children to be synced for a given callback. If we set a limit of 100, we will initially only receive up to 100 child_added events. If we have fewer than 100 messages stored in our Database, a child_added event will fire for each message. However, if we have over 100 messages, we will only receive a child_added event for the last 100 ordered messages. As items change, we will receive child_removed events for each item that drops out of the active list so that the total number stays at 100.

                                                                                                                                                                                                                                                                                                                        You can read more about limitToLast() in .

                                                                                                                                                                                                                                                                                                                        Parameter limit

                                                                                                                                                                                                                                                                                                                        The maximum number of nodes to include in this query.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        // Find the two heaviest dinosaurs.
                                                                                                                                                                                                                                                                                                                        var ref = firebase.database().ref("dinosaurs");
                                                                                                                                                                                                                                                                                                                        ref.orderByChild("weight").limitToLast(2).on("child_added", function(snapshot) {
                                                                                                                                                                                                                                                                                                                        // This callback will be triggered exactly two times, unless there are
                                                                                                                                                                                                                                                                                                                        // fewer than two dinosaurs stored in the Database. It will also get fired
                                                                                                                                                                                                                                                                                                                        // for every new, heavier dinosaur that gets added to the data set.
                                                                                                                                                                                                                                                                                                                        console.log(snapshot.key);
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                      method off

                                                                                                                                                                                                                                                                                                                      off: (
                                                                                                                                                                                                                                                                                                                      eventType?: EventType,
                                                                                                                                                                                                                                                                                                                      callback?: (a: DataSnapshot, b?: string | null) => any,
                                                                                                                                                                                                                                                                                                                      context?: Object | null
                                                                                                                                                                                                                                                                                                                      ) => void;
                                                                                                                                                                                                                                                                                                                      • Detaches a callback previously attached with on().

                                                                                                                                                                                                                                                                                                                        Detach a callback previously attached with on(). Note that if on() was called multiple times with the same eventType and callback, the callback will be called multiple times for each event, and off() must be called multiple times to remove the callback. Calling off() on a parent listener will not automatically remove listeners registered on child nodes, off() must also be called on any child listeners to remove the callback.

                                                                                                                                                                                                                                                                                                                        If a callback is not specified, all callbacks for the specified eventType will be removed. Similarly, if no eventType is specified, all callbacks for the Reference will be removed.

                                                                                                                                                                                                                                                                                                                        Parameter eventType

                                                                                                                                                                                                                                                                                                                        One of the following strings: "value", "child_added", "child_changed", "child_removed", or "child_moved." If omitted, all callbacks for the Reference will be removed.

                                                                                                                                                                                                                                                                                                                        Parameter callback

                                                                                                                                                                                                                                                                                                                        The callback function that was passed to on() or undefined to remove all callbacks.

                                                                                                                                                                                                                                                                                                                        Parameter context

                                                                                                                                                                                                                                                                                                                        The context that was passed to on().

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        var onValueChange = function(dataSnapshot) { ... };
                                                                                                                                                                                                                                                                                                                        ref.on('value', onValueChange);
                                                                                                                                                                                                                                                                                                                        ref.child('meta-data').on('child_added', onChildAdded);
                                                                                                                                                                                                                                                                                                                        // Sometime later...
                                                                                                                                                                                                                                                                                                                        ref.off('value', onValueChange);
                                                                                                                                                                                                                                                                                                                        // You must also call off() for any child listeners on ref
                                                                                                                                                                                                                                                                                                                        // to cancel those callbacks
                                                                                                                                                                                                                                                                                                                        ref.child('meta-data').off('child_added', onValueAdded);

                                                                                                                                                                                                                                                                                                                        Example 2

                                                                                                                                                                                                                                                                                                                        // Or you can save a line of code by using an inline function
                                                                                                                                                                                                                                                                                                                        // and on()'s return value.
                                                                                                                                                                                                                                                                                                                        var onValueChange = ref.on('value', function(dataSnapshot) { ... });
                                                                                                                                                                                                                                                                                                                        // Sometime later...
                                                                                                                                                                                                                                                                                                                        ref.off('value', onValueChange);

                                                                                                                                                                                                                                                                                                                      method on

                                                                                                                                                                                                                                                                                                                      on: (
                                                                                                                                                                                                                                                                                                                      eventType: EventType,
                                                                                                                                                                                                                                                                                                                      callback: (a: DataSnapshot, b?: string | null) => any,
                                                                                                                                                                                                                                                                                                                      cancelCallbackOrContext?: Object | ((a: Error) => any),
                                                                                                                                                                                                                                                                                                                      context?: Object | null
                                                                                                                                                                                                                                                                                                                      ) => (a: DataSnapshot, b?: string | null) => any;
                                                                                                                                                                                                                                                                                                                      • Listens for data changes at a particular location.

                                                                                                                                                                                                                                                                                                                        This is the primary way to read data from a Database. Your callback will be triggered for the initial data and again whenever the data changes. Use off( ) to stop receiving updates. See for more details.

                                                                                                                                                                                                                                                                                                                        value event

                                                                                                                                                                                                                                                                                                                        This event will trigger once with the initial data stored at this location, and then trigger again each time the data changes. The DataSnapshot passed to the callback will be for the location at which on() was called. It won't trigger until the entire contents has been synchronized. If the location has no data, it will be triggered with an empty DataSnapshot (val() will return null).

                                                                                                                                                                                                                                                                                                                        child_added event

                                                                                                                                                                                                                                                                                                                        This event will be triggered once for each initial child at this location, and it will be triggered again every time a new child is added. The DataSnapshot passed into the callback will reflect the data for the relevant child. For ordering purposes, it is passed a second argument which is a string containing the key of the previous sibling child by sort order, or null if it is the first child.

                                                                                                                                                                                                                                                                                                                        child_removed event

                                                                                                                                                                                                                                                                                                                        This event will be triggered once every time a child is removed. The DataSnapshot passed into the callback will be the old data for the child that was removed. A child will get removed when either:

                                                                                                                                                                                                                                                                                                                        - a client explicitly calls remove() on that child or one of its ancestors - a client calls set(null) on that child or one of its ancestors - that child has all of its children removed - there is a query in effect which now filters out the child (because it's sort order changed or the max limit was hit)

                                                                                                                                                                                                                                                                                                                        child_changed event

                                                                                                                                                                                                                                                                                                                        This event will be triggered when the data stored in a child (or any of its descendants) changes. Note that a single child_changed event may represent multiple changes to the child. The DataSnapshot passed to the callback will contain the new child contents. For ordering purposes, the callback is also passed a second argument which is a string containing the key of the previous sibling child by sort order, or null if it is the first child.

                                                                                                                                                                                                                                                                                                                        child_moved event

                                                                                                                                                                                                                                                                                                                        This event will be triggered when a child's sort order changes such that its position relative to its siblings changes. The DataSnapshot passed to the callback will be for the data of the child that has moved. It is also passed a second argument which is a string containing the key of the previous sibling child by sort order, or null if it is the first child.

                                                                                                                                                                                                                                                                                                                        Parameter eventType

                                                                                                                                                                                                                                                                                                                        One of the following strings: "value", "child_added", "child_changed", "child_removed", or "child_moved."

                                                                                                                                                                                                                                                                                                                        Parameter callback

                                                                                                                                                                                                                                                                                                                        A callback that fires when the specified event occurs. The callback will be passed a DataSnapshot. For ordering purposes, "child_added", "child_changed", and "child_moved" will also be passed a string containing the key of the previous child, by sort order, or null if it is the first child.

                                                                                                                                                                                                                                                                                                                        Parameter cancelCallbackOrContext

                                                                                                                                                                                                                                                                                                                        An optional callback that will be notified if your event subscription is ever canceled because your client does not have permission to read this data (or it had permission but has now lost it). This callback will be passed an Error object indicating why the failure occurred.

                                                                                                                                                                                                                                                                                                                        Parameter context

                                                                                                                                                                                                                                                                                                                        If provided, this object will be used as this when calling your callback(s). The provided callback function is returned unmodified. This is just for convenience if you want to pass an inline function to on() but store the callback function for later passing to off().

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        **Handle a new value:**

                                                                                                                                                                                                                                                                                                                        ref.on('value', function(dataSnapshot) {
                                                                                                                                                                                                                                                                                                                        ...
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                        Example 2

                                                                                                                                                                                                                                                                                                                        **Handle a new child:**

                                                                                                                                                                                                                                                                                                                        ref.on('child_added', function(childSnapshot, prevChildKey) {
                                                                                                                                                                                                                                                                                                                        ...
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                        Example 3

                                                                                                                                                                                                                                                                                                                        **Handle child removal:**

                                                                                                                                                                                                                                                                                                                        ref.on('child_removed', function(oldChildSnapshot) {
                                                                                                                                                                                                                                                                                                                        ...
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                        Example 4

                                                                                                                                                                                                                                                                                                                        **Handle child data changes:**

                                                                                                                                                                                                                                                                                                                        ref.on('child_changed', function(childSnapshot, prevChildKey) {
                                                                                                                                                                                                                                                                                                                        ...
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                        Example 5

                                                                                                                                                                                                                                                                                                                        **Handle child ordering changes:**

                                                                                                                                                                                                                                                                                                                        ref.on('child_moved', function(childSnapshot, prevChildKey) {
                                                                                                                                                                                                                                                                                                                        ...
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                      method once

                                                                                                                                                                                                                                                                                                                      once: (
                                                                                                                                                                                                                                                                                                                      eventType: EventType,
                                                                                                                                                                                                                                                                                                                      successCallback?: (a: DataSnapshot, b?: string | null) => any,
                                                                                                                                                                                                                                                                                                                      failureCallbackOrContext?: Object | ((a: Error) => void),
                                                                                                                                                                                                                                                                                                                      context?: Object | null
                                                                                                                                                                                                                                                                                                                      ) => Promise<DataSnapshot>;
                                                                                                                                                                                                                                                                                                                      • Listens for exactly one event of the specified event type, and then stops listening.

                                                                                                                                                                                                                                                                                                                        This is equivalent to calling , and then calling inside the callback function. See for details on the event types.

                                                                                                                                                                                                                                                                                                                        Parameter eventType

                                                                                                                                                                                                                                                                                                                        One of the following strings: "value", "child_added", "child_changed", "child_removed", or "child_moved."

                                                                                                                                                                                                                                                                                                                        Parameter successCallback

                                                                                                                                                                                                                                                                                                                        A callback that fires when the specified event occurs. The callback will be passed a DataSnapshot. For ordering purposes, "child_added", "child_changed", and "child_moved" will also be passed a string containing the key of the previous child by sort order, or null if it is the first child.

                                                                                                                                                                                                                                                                                                                        Parameter failureCallbackOrContext

                                                                                                                                                                                                                                                                                                                        An optional callback that will be notified if your client does not have permission to read the data. This callback will be passed an Error object indicating why the failure occurred.

                                                                                                                                                                                                                                                                                                                        Parameter context

                                                                                                                                                                                                                                                                                                                        If provided, this object will be used as this when calling your callback(s).

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        // Basic usage of .once() to read the data located at ref.
                                                                                                                                                                                                                                                                                                                        ref.once('value')
                                                                                                                                                                                                                                                                                                                        .then(function(dataSnapshot) {
                                                                                                                                                                                                                                                                                                                        // handle read data.
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                      method orderByChild

                                                                                                                                                                                                                                                                                                                      orderByChild: (path: string) => Query;
                                                                                                                                                                                                                                                                                                                      • Generates a new Query object ordered by the specified child key.

                                                                                                                                                                                                                                                                                                                        Queries can only order by one key at a time. Calling orderByChild() multiple times on the same query is an error.

                                                                                                                                                                                                                                                                                                                        Firebase queries allow you to order your data by any child key on the fly. However, if you know in advance what your indexes will be, you can define them via the .indexOn rule in your Security Rules for better performance. See the rule for more information.

                                                                                                                                                                                                                                                                                                                        You can read more about orderByChild() in .

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        var ref = firebase.database().ref("dinosaurs");
                                                                                                                                                                                                                                                                                                                        ref.orderByChild("height").on("child_added", function(snapshot) {
                                                                                                                                                                                                                                                                                                                        console.log(snapshot.key + " was " + snapshot.val().height + " m tall");
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                      method orderByKey

                                                                                                                                                                                                                                                                                                                      orderByKey: () => Query;
                                                                                                                                                                                                                                                                                                                      • Generates a new Query object ordered by key.

                                                                                                                                                                                                                                                                                                                        Sorts the results of a query by their (ascending) key values.

                                                                                                                                                                                                                                                                                                                        You can read more about orderByKey() in .

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        var ref = firebase.database().ref("dinosaurs");
                                                                                                                                                                                                                                                                                                                        ref.orderByKey().on("child_added", function(snapshot) {
                                                                                                                                                                                                                                                                                                                        console.log(snapshot.key);
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                      method orderByPriority

                                                                                                                                                                                                                                                                                                                      orderByPriority: () => Query;
                                                                                                                                                                                                                                                                                                                      • Generates a new Query object ordered by priority.

                                                                                                                                                                                                                                                                                                                        Applications need not use priority but can order collections by ordinary properties (see for alternatives to priority.

                                                                                                                                                                                                                                                                                                                      method orderByValue

                                                                                                                                                                                                                                                                                                                      orderByValue: () => Query;
                                                                                                                                                                                                                                                                                                                      • Generates a new Query object ordered by value.

                                                                                                                                                                                                                                                                                                                        If the children of a query are all scalar values (string, number, or boolean), you can order the results by their (ascending) values.

                                                                                                                                                                                                                                                                                                                        You can read more about orderByValue() in .

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        var scoresRef = firebase.database().ref("scores");
                                                                                                                                                                                                                                                                                                                        scoresRef.orderByValue().limitToLast(3).on("value", function(snapshot) {
                                                                                                                                                                                                                                                                                                                        snapshot.forEach(function(data) {
                                                                                                                                                                                                                                                                                                                        console.log("The " + data.key + " score is " + data.val());
                                                                                                                                                                                                                                                                                                                        });
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                      method startAfter

                                                                                                                                                                                                                                                                                                                      startAfter: (value: number | string | boolean | null, key?: string) => Query;
                                                                                                                                                                                                                                                                                                                      • Creates a Query with the specified starting point (exclusive).

                                                                                                                                                                                                                                                                                                                        Using startAt(), startAfter(), endBefore(), endAt() and equalTo() allows you to choose arbitrary starting and ending points for your queries.

                                                                                                                                                                                                                                                                                                                        The starting point is exclusive. If only a value is provided, children with a value greater than the specified value will be included in the query. If a key is specified, then children must have a value greater than or equal to the specified value and a a key name greater than the specified key.

                                                                                                                                                                                                                                                                                                                        Parameter value

                                                                                                                                                                                                                                                                                                                        The value to start after. The argument type depends on which orderBy*() function was used in this query. Specify a value that matches the orderBy*() type. When used in combination with orderByKey(), the value must be a string.

                                                                                                                                                                                                                                                                                                                        Parameter key

                                                                                                                                                                                                                                                                                                                        The child key to start after. This argument is only allowed if ordering by child, value, or priority.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        // Find all dinosaurs that are more than three meters tall.
                                                                                                                                                                                                                                                                                                                        var ref = firebase.database().ref("dinosaurs");
                                                                                                                                                                                                                                                                                                                        ref.orderByChild("height").startAfter(3).on("child_added", function(snapshot) {
                                                                                                                                                                                                                                                                                                                        console.log(snapshot.key)
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                      method startAt

                                                                                                                                                                                                                                                                                                                      startAt: (value: number | string | boolean | null, key?: string) => Query;
                                                                                                                                                                                                                                                                                                                      • Creates a Query with the specified starting point.

                                                                                                                                                                                                                                                                                                                        Using startAt(), startAfter(), endBefore(), endAt() and equalTo() allows you to choose arbitrary starting and ending points for your queries.

                                                                                                                                                                                                                                                                                                                        The starting point is inclusive, so children with exactly the specified value will be included in the query. The optional key argument can be used to further limit the range of the query. If it is specified, then children that have exactly the specified value must also have a key name greater than or equal to the specified key.

                                                                                                                                                                                                                                                                                                                        You can read more about startAt() in .

                                                                                                                                                                                                                                                                                                                        Parameter value

                                                                                                                                                                                                                                                                                                                        The value to start at. The argument type depends on which orderBy*() function was used in this query. Specify a value that matches the orderBy*() type. When used in combination with orderByKey(), the value must be a string.

                                                                                                                                                                                                                                                                                                                        Parameter key

                                                                                                                                                                                                                                                                                                                        The child key to start at. This argument is only allowed if ordering by child, value, or priority.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        // Find all dinosaurs that are at least three meters tall.
                                                                                                                                                                                                                                                                                                                        var ref = firebase.database().ref("dinosaurs");
                                                                                                                                                                                                                                                                                                                        ref.orderByChild("height").startAt(3).on("child_added", function(snapshot) {
                                                                                                                                                                                                                                                                                                                        console.log(snapshot.key)
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                      method toJSON

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

                                                                                                                                                                                                                                                                                                                        A JSON-serializable representation of this object.

                                                                                                                                                                                                                                                                                                                      method toString

                                                                                                                                                                                                                                                                                                                      toString: () => string;
                                                                                                                                                                                                                                                                                                                      • Gets the absolute URL for this location.

                                                                                                                                                                                                                                                                                                                        The toString() method returns a URL that is ready to be put into a browser, curl command, or a firebase.database().refFromURL() call. Since all of those expect the URL to be url-encoded, toString() returns an encoded URL.

                                                                                                                                                                                                                                                                                                                        Append '.json' to the returned URL when typed into a browser to download JSON-formatted data. If the location is secured (that is, not publicly readable), you will get a permission-denied error.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        // Calling toString() on a root Firebase reference returns the URL where its
                                                                                                                                                                                                                                                                                                                        // data is stored within the Database:
                                                                                                                                                                                                                                                                                                                        var rootRef = firebase.database().ref();
                                                                                                                                                                                                                                                                                                                        var rootUrl = rootRef.toString();
                                                                                                                                                                                                                                                                                                                        // rootUrl === "https://sample-app.firebaseio.com/".
                                                                                                                                                                                                                                                                                                                        // Calling toString() at a deeper Firebase reference returns the URL of that
                                                                                                                                                                                                                                                                                                                        // deep path within the Database:
                                                                                                                                                                                                                                                                                                                        var adaRef = rootRef.child('users/ada');
                                                                                                                                                                                                                                                                                                                        var adaURL = adaRef.toString();
                                                                                                                                                                                                                                                                                                                        // adaURL === "https://sample-app.firebaseio.com/users/ada".

                                                                                                                                                                                                                                                                                                                        The absolute URL for this location.

                                                                                                                                                                                                                                                                                                                      interface Reference

                                                                                                                                                                                                                                                                                                                      interface Reference extends firebase.database.Query {}
                                                                                                                                                                                                                                                                                                                      • A Reference represents a specific location in your Database and can be used for reading or writing data to that Database location.

                                                                                                                                                                                                                                                                                                                        You can reference the root or child location in your Database by calling firebase.database().ref() or firebase.database().ref("child/path").

                                                                                                                                                                                                                                                                                                                        Writing is done with the set() method and reading can be done with the on() method. See

                                                                                                                                                                                                                                                                                                                      property key

                                                                                                                                                                                                                                                                                                                      key: string | null;
                                                                                                                                                                                                                                                                                                                      • The last part of the Reference's path.

                                                                                                                                                                                                                                                                                                                        For example, "ada" is the key for https://<DATABASE_NAME>.firebaseio.com/users/ada.

                                                                                                                                                                                                                                                                                                                        The key of a root Reference is null.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        // The key of a root reference is null
                                                                                                                                                                                                                                                                                                                        var rootRef = firebase.database().ref();
                                                                                                                                                                                                                                                                                                                        var key = rootRef.key; // key === null

                                                                                                                                                                                                                                                                                                                        Example 2

                                                                                                                                                                                                                                                                                                                        // The key of any non-root reference is the last token in the path
                                                                                                                                                                                                                                                                                                                        var adaRef = firebase.database().ref("users/ada");
                                                                                                                                                                                                                                                                                                                        var key = adaRef.key; // key === "ada"
                                                                                                                                                                                                                                                                                                                        key = adaRef.child("name/last").key; // key === "last"

                                                                                                                                                                                                                                                                                                                      property parent

                                                                                                                                                                                                                                                                                                                      parent: firebase.database.Reference | null;
                                                                                                                                                                                                                                                                                                                      • The parent location of a Reference.

                                                                                                                                                                                                                                                                                                                        The parent of a root Reference is null.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        // The parent of a root reference is null
                                                                                                                                                                                                                                                                                                                        var rootRef = firebase.database().ref();
                                                                                                                                                                                                                                                                                                                        parent = rootRef.parent; // parent === null

                                                                                                                                                                                                                                                                                                                        Example 2

                                                                                                                                                                                                                                                                                                                        // The parent of any non-root reference is the parent location
                                                                                                                                                                                                                                                                                                                        var usersRef = firebase.database().ref("users");
                                                                                                                                                                                                                                                                                                                        var adaRef = firebase.database().ref("users/ada");
                                                                                                                                                                                                                                                                                                                        // usersRef and adaRef.parent represent the same location

                                                                                                                                                                                                                                                                                                                      property root

                                                                                                                                                                                                                                                                                                                      root: firebase.database.Reference;
                                                                                                                                                                                                                                                                                                                      • The root Reference of the Database.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        // The root of a root reference is itself
                                                                                                                                                                                                                                                                                                                        var rootRef = firebase.database().ref();
                                                                                                                                                                                                                                                                                                                        // rootRef and rootRef.root represent the same location

                                                                                                                                                                                                                                                                                                                        Example 2

                                                                                                                                                                                                                                                                                                                        // The root of any non-root reference is the root location
                                                                                                                                                                                                                                                                                                                        var adaRef = firebase.database().ref("users/ada");
                                                                                                                                                                                                                                                                                                                        // rootRef and adaRef.root represent the same location

                                                                                                                                                                                                                                                                                                                      method child

                                                                                                                                                                                                                                                                                                                      child: (path: string) => Reference;
                                                                                                                                                                                                                                                                                                                      • Gets a Reference for the location at the specified relative path.

                                                                                                                                                                                                                                                                                                                        The relative path can either be a simple child name (for example, "ada") or a deeper slash-separated path (for example, "ada/name/first").

                                                                                                                                                                                                                                                                                                                        Parameter path

                                                                                                                                                                                                                                                                                                                        A relative path from this location to the desired child location. The specified child location.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        var usersRef = firebase.database().ref('users');
                                                                                                                                                                                                                                                                                                                        var adaRef = usersRef.child('ada');
                                                                                                                                                                                                                                                                                                                        var adaFirstNameRef = adaRef.child('name/first');
                                                                                                                                                                                                                                                                                                                        var path = adaFirstNameRef.toString();
                                                                                                                                                                                                                                                                                                                        // path is now 'https://sample-app.firebaseio.com/users/ada/name/first'

                                                                                                                                                                                                                                                                                                                      method onDisconnect

                                                                                                                                                                                                                                                                                                                      onDisconnect: () => OnDisconnect;
                                                                                                                                                                                                                                                                                                                      • Returns an OnDisconnect object - see for more information on how to use it.

                                                                                                                                                                                                                                                                                                                      method push

                                                                                                                                                                                                                                                                                                                      push: (value?: any, onComplete?: (a: Error | null) => any) => ThenableReference;
                                                                                                                                                                                                                                                                                                                      • Generates a new child location using a unique key and returns its Reference.

                                                                                                                                                                                                                                                                                                                        This is the most common pattern for adding data to a collection of items.

                                                                                                                                                                                                                                                                                                                        If you provide a value to push(), the value is written to the generated location. If you don't pass a value, nothing is written to the database and the child remains empty (but you can use the Reference elsewhere).

                                                                                                                                                                                                                                                                                                                        The unique keys generated by push() are ordered by the current time, so the resulting list of items is chronologically sorted. The keys are also designed to be unguessable (they contain 72 random bits of entropy).

                                                                                                                                                                                                                                                                                                                        See See

                                                                                                                                                                                                                                                                                                                        Parameter value

                                                                                                                                                                                                                                                                                                                        Optional value to be written at the generated location.

                                                                                                                                                                                                                                                                                                                        Parameter onComplete

                                                                                                                                                                                                                                                                                                                        Callback called when write to server is complete. Combined Promise and Reference; resolves when write is complete, but can be used immediately as the Reference to the child location.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        var messageListRef = firebase.database().ref('message_list');
                                                                                                                                                                                                                                                                                                                        var newMessageRef = messageListRef.push();
                                                                                                                                                                                                                                                                                                                        newMessageRef.set({
                                                                                                                                                                                                                                                                                                                        'user_id': 'ada',
                                                                                                                                                                                                                                                                                                                        'text': 'The Analytical Engine weaves algebraical patterns just as the Jacquard loom weaves flowers and leaves.'
                                                                                                                                                                                                                                                                                                                        });
                                                                                                                                                                                                                                                                                                                        // We've appended a new message to the message_list location.
                                                                                                                                                                                                                                                                                                                        var path = newMessageRef.toString();
                                                                                                                                                                                                                                                                                                                        // path will be something like
                                                                                                                                                                                                                                                                                                                        // 'https://sample-app.firebaseio.com/message_list/-IKo28nwJLH0Nc5XeFmj'

                                                                                                                                                                                                                                                                                                                      method remove

                                                                                                                                                                                                                                                                                                                      remove: (onComplete?: (a: Error | null) => void) => Promise<void>;
                                                                                                                                                                                                                                                                                                                      • Removes the data at this Database location.

                                                                                                                                                                                                                                                                                                                        Any data at child locations will also be deleted.

                                                                                                                                                                                                                                                                                                                        The effect of the remove will be visible immediately and the corresponding event 'value' will be triggered. Synchronization of the remove to the Firebase servers will also be started, and the returned Promise will resolve when complete. If provided, the onComplete callback will be called asynchronously after synchronization has finished.

                                                                                                                                                                                                                                                                                                                        Parameter onComplete

                                                                                                                                                                                                                                                                                                                        Callback called when write to server is complete. Resolves when remove on server is complete.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        var adaRef = firebase.database().ref('users/ada');
                                                                                                                                                                                                                                                                                                                        adaRef.remove()
                                                                                                                                                                                                                                                                                                                        .then(function() {
                                                                                                                                                                                                                                                                                                                        console.log("Remove succeeded.")
                                                                                                                                                                                                                                                                                                                        })
                                                                                                                                                                                                                                                                                                                        .catch(function(error) {
                                                                                                                                                                                                                                                                                                                        console.log("Remove failed: " + error.message)
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                      method set

                                                                                                                                                                                                                                                                                                                      set: (value: any, onComplete?: (a: Error | null) => void) => Promise<void>;
                                                                                                                                                                                                                                                                                                                      • Writes data to this Database location.

                                                                                                                                                                                                                                                                                                                        This will overwrite any data at this location and all child locations.

                                                                                                                                                                                                                                                                                                                        The effect of the write will be visible immediately, and the corresponding events ("value", "child_added", etc.) will be triggered. Synchronization of the data to the Firebase servers will also be started, and the returned Promise will resolve when complete. If provided, the onComplete callback will be called asynchronously after synchronization has finished.

                                                                                                                                                                                                                                                                                                                        Passing null for the new value is equivalent to calling remove(); namely, all data at this location and all child locations will be deleted.

                                                                                                                                                                                                                                                                                                                        set() will remove any priority stored at this location, so if priority is meant to be preserved, you need to use setWithPriority() instead.

                                                                                                                                                                                                                                                                                                                        Note that modifying data with set() will cancel any pending transactions at that location, so extreme care should be taken if mixing set() and transaction() to modify the same data.

                                                                                                                                                                                                                                                                                                                        A single set() will generate a single "value" event at the location where the set() was performed.

                                                                                                                                                                                                                                                                                                                        Parameter value

                                                                                                                                                                                                                                                                                                                        The value to be written (string, number, boolean, object, array, or null).

                                                                                                                                                                                                                                                                                                                        Parameter onComplete

                                                                                                                                                                                                                                                                                                                        Callback called when write to server is complete. Resolves when write to server is complete.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        var adaNameRef = firebase.database().ref('users/ada/name');
                                                                                                                                                                                                                                                                                                                        adaNameRef.child('first').set('Ada');
                                                                                                                                                                                                                                                                                                                        adaNameRef.child('last').set('Lovelace');
                                                                                                                                                                                                                                                                                                                        // We've written 'Ada' to the Database location storing Ada's first name,
                                                                                                                                                                                                                                                                                                                        // and 'Lovelace' to the location storing her last name.

                                                                                                                                                                                                                                                                                                                        Example 2

                                                                                                                                                                                                                                                                                                                        adaNameRef.set({ first: 'Ada', last: 'Lovelace' });
                                                                                                                                                                                                                                                                                                                        // Exact same effect as the previous example, except we've written
                                                                                                                                                                                                                                                                                                                        // Ada's first and last name simultaneously.

                                                                                                                                                                                                                                                                                                                        Example 3

                                                                                                                                                                                                                                                                                                                        adaNameRef.set({ first: 'Ada', last: 'Lovelace' })
                                                                                                                                                                                                                                                                                                                        .then(function() {
                                                                                                                                                                                                                                                                                                                        console.log('Synchronization succeeded');
                                                                                                                                                                                                                                                                                                                        })
                                                                                                                                                                                                                                                                                                                        .catch(function(error) {
                                                                                                                                                                                                                                                                                                                        console.log('Synchronization failed');
                                                                                                                                                                                                                                                                                                                        });
                                                                                                                                                                                                                                                                                                                        // Same as the previous example, except we will also log a message
                                                                                                                                                                                                                                                                                                                        // when the data has finished synchronizing.

                                                                                                                                                                                                                                                                                                                      method setPriority

                                                                                                                                                                                                                                                                                                                      setPriority: (
                                                                                                                                                                                                                                                                                                                      priority: string | number | null,
                                                                                                                                                                                                                                                                                                                      onComplete: (a: Error | null) => void
                                                                                                                                                                                                                                                                                                                      ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                      • Sets a priority for the data at this Database location.

                                                                                                                                                                                                                                                                                                                        Applications need not use priority but can order collections by ordinary properties (see ).

                                                                                                                                                                                                                                                                                                                      method setWithPriority

                                                                                                                                                                                                                                                                                                                      setWithPriority: (
                                                                                                                                                                                                                                                                                                                      newVal: any,
                                                                                                                                                                                                                                                                                                                      newPriority: string | number | null,
                                                                                                                                                                                                                                                                                                                      onComplete?: (a: Error | null) => void
                                                                                                                                                                                                                                                                                                                      ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                      • Writes data the Database location. Like set() but also specifies the priority for that data.

                                                                                                                                                                                                                                                                                                                        Applications need not use priority but can order collections by ordinary properties (see ).

                                                                                                                                                                                                                                                                                                                      method transaction

                                                                                                                                                                                                                                                                                                                      transaction: (
                                                                                                                                                                                                                                                                                                                      transactionUpdate: (a: any) => any,
                                                                                                                                                                                                                                                                                                                      onComplete?: (a: Error | null, b: boolean, c: DataSnapshot) => void,
                                                                                                                                                                                                                                                                                                                      applyLocally?: boolean
                                                                                                                                                                                                                                                                                                                      ) => Promise<TransactionResult>;
                                                                                                                                                                                                                                                                                                                      • Atomically modifies the data at this location.

                                                                                                                                                                                                                                                                                                                        Atomically modify the data at this location. Unlike a normal set(), which just overwrites the data regardless of its previous value, transaction() is used to modify the existing value to a new value, ensuring there are no conflicts with other clients writing to the same location at the same time.

                                                                                                                                                                                                                                                                                                                        To accomplish this, you pass transaction() an update function which is used to transform the current value into a new value. If another client writes to the location before your new value is successfully written, your update function will be called again with the new current value, and the write will be retried. This will happen repeatedly until your write succeeds without conflict or you abort the transaction by not returning a value from your update function.

                                                                                                                                                                                                                                                                                                                        Note: Modifying data with set() will cancel any pending transactions at that location, so extreme care should be taken if mixing set() and transaction() to update the same data.

                                                                                                                                                                                                                                                                                                                        Note: When using transactions with Security and Firebase Rules in place, be aware that a client needs .read access in addition to .write access in order to perform a transaction. This is because the client-side nature of transactions requires the client to read the data in order to transactionally update it.

                                                                                                                                                                                                                                                                                                                        Parameter transactionUpdate

                                                                                                                                                                                                                                                                                                                        A developer-supplied function which will be passed the current data stored at this location (as a JavaScript object). The function should return the new value it would like written (as a JavaScript object). If undefined is returned (i.e. you return with no arguments) the transaction will be aborted and the data at this location will not be modified.

                                                                                                                                                                                                                                                                                                                        Parameter onComplete

                                                                                                                                                                                                                                                                                                                        A callback function that will be called when the transaction completes. The callback is passed three arguments: a possibly-null Error, a boolean indicating whether the transaction was committed, and a DataSnapshot indicating the final result. If the transaction failed abnormally, the first argument will be an Error object indicating the failure cause. If the transaction finished normally, but no data was committed because no data was returned from transactionUpdate, then second argument will be false. If the transaction completed and committed data to Firebase, the second argument will be true. Regardless, the third argument will be a DataSnapshot containing the resulting data in this location.

                                                                                                                                                                                                                                                                                                                        Parameter applyLocally

                                                                                                                                                                                                                                                                                                                        By default, events are raised each time the transaction update function runs. So if it is run multiple times, you may see intermediate states. You can set this to false to suppress these intermediate states and instead wait until the transaction has completed before events are raised. Returns a Promise that can optionally be used instead of the onComplete callback to handle success and failure.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        // Increment Ada's rank by 1.
                                                                                                                                                                                                                                                                                                                        var adaRankRef = firebase.database().ref('users/ada/rank');
                                                                                                                                                                                                                                                                                                                        adaRankRef.transaction(function(currentRank) {
                                                                                                                                                                                                                                                                                                                        // If users/ada/rank has never been set, currentRank will be `null`.
                                                                                                                                                                                                                                                                                                                        return currentRank + 1;
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                        Example 2

                                                                                                                                                                                                                                                                                                                        // Try to create a user for ada, but only if the user id 'ada' isn't
                                                                                                                                                                                                                                                                                                                        // already taken
                                                                                                                                                                                                                                                                                                                        var adaRef = firebase.database().ref('users/ada');
                                                                                                                                                                                                                                                                                                                        adaRef.transaction(function(currentData) {
                                                                                                                                                                                                                                                                                                                        if (currentData === null) {
                                                                                                                                                                                                                                                                                                                        return { name: { first: 'Ada', last: 'Lovelace' } };
                                                                                                                                                                                                                                                                                                                        } else {
                                                                                                                                                                                                                                                                                                                        console.log('User ada already exists.');
                                                                                                                                                                                                                                                                                                                        return; // Abort the transaction.
                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                        }, function(error, committed, snapshot) {
                                                                                                                                                                                                                                                                                                                        if (error) {
                                                                                                                                                                                                                                                                                                                        console.log('Transaction failed abnormally!', error);
                                                                                                                                                                                                                                                                                                                        } else if (!committed) {
                                                                                                                                                                                                                                                                                                                        console.log('We aborted the transaction (because ada already exists).');
                                                                                                                                                                                                                                                                                                                        } else {
                                                                                                                                                                                                                                                                                                                        console.log('User ada added!');
                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                        console.log("Ada's data: ", snapshot.val());
                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                      method update

                                                                                                                                                                                                                                                                                                                      update: (
                                                                                                                                                                                                                                                                                                                      values: Object,
                                                                                                                                                                                                                                                                                                                      onComplete?: (a: Error | null) => void
                                                                                                                                                                                                                                                                                                                      ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                      • Writes multiple values to the Database at once.

                                                                                                                                                                                                                                                                                                                        The values argument contains multiple property-value pairs that will be written to the Database together. Each child property can either be a simple property (for example, "name") or a relative path (for example, "name/first") from the current location to the data to update.

                                                                                                                                                                                                                                                                                                                        As opposed to the set() method, update() can be use to selectively update only the referenced properties at the current location (instead of replacing all the child properties at the current location).

                                                                                                                                                                                                                                                                                                                        The effect of the write will be visible immediately, and the corresponding events ('value', 'child_added', etc.) will be triggered. Synchronization of the data to the Firebase servers will also be started, and the returned Promise will resolve when complete. If provided, the onComplete callback will be called asynchronously after synchronization has finished.

                                                                                                                                                                                                                                                                                                                        A single update() will generate a single "value" event at the location where the update() was performed, regardless of how many children were modified.

                                                                                                                                                                                                                                                                                                                        Note that modifying data with update() will cancel any pending transactions at that location, so extreme care should be taken if mixing update() and transaction() to modify the same data.

                                                                                                                                                                                                                                                                                                                        Passing null to update() will remove the data at this location.

                                                                                                                                                                                                                                                                                                                        See .

                                                                                                                                                                                                                                                                                                                        Parameter values

                                                                                                                                                                                                                                                                                                                        Object containing multiple values.

                                                                                                                                                                                                                                                                                                                        Parameter onComplete

                                                                                                                                                                                                                                                                                                                        Callback called when write to server is complete. Resolves when update on server is complete.

                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                        var adaNameRef = firebase.database().ref('users/ada/name');
                                                                                                                                                                                                                                                                                                                        // Modify the 'first' and 'last' properties, but leave other data at
                                                                                                                                                                                                                                                                                                                        // adaNameRef unchanged.
                                                                                                                                                                                                                                                                                                                        adaNameRef.update({ first: 'Ada', last: 'Lovelace' });

                                                                                                                                                                                                                                                                                                                      interface ThenableReference

                                                                                                                                                                                                                                                                                                                      interface ThenableReference
                                                                                                                                                                                                                                                                                                                      extends firebase.database.Reference,
                                                                                                                                                                                                                                                                                                                      Pick<Promise<Reference>, 'then' | 'catch'> {}

                                                                                                                                                                                                                                                                                                                        interface TransactionResult

                                                                                                                                                                                                                                                                                                                        interface TransactionResult {}

                                                                                                                                                                                                                                                                                                                          property committed

                                                                                                                                                                                                                                                                                                                          committed: boolean;
                                                                                                                                                                                                                                                                                                                          • Whether the transaction was successfully committed.

                                                                                                                                                                                                                                                                                                                          property snapshot

                                                                                                                                                                                                                                                                                                                          snapshot: DataSnapshot;
                                                                                                                                                                                                                                                                                                                          • The resulting data snapshot.

                                                                                                                                                                                                                                                                                                                          type EmulatorMockTokenOptions

                                                                                                                                                                                                                                                                                                                          type EmulatorMockTokenOptions = firebase.EmulatorMockTokenOptions;

                                                                                                                                                                                                                                                                                                                            type EventType

                                                                                                                                                                                                                                                                                                                            type EventType =
                                                                                                                                                                                                                                                                                                                            | 'value'
                                                                                                                                                                                                                                                                                                                            | 'child_added'
                                                                                                                                                                                                                                                                                                                            | 'child_changed'
                                                                                                                                                                                                                                                                                                                            | 'child_moved'
                                                                                                                                                                                                                                                                                                                            | 'child_removed';

                                                                                                                                                                                                                                                                                                                              namespace firebase.database.ServerValue

                                                                                                                                                                                                                                                                                                                              namespace firebase.database.ServerValue {}

                                                                                                                                                                                                                                                                                                                                variable TIMESTAMP

                                                                                                                                                                                                                                                                                                                                var TIMESTAMP: Object;
                                                                                                                                                                                                                                                                                                                                • A placeholder value for auto-populating the current timestamp (time since the Unix epoch, in milliseconds) as determined by the Firebase servers.

                                                                                                                                                                                                                                                                                                                                  Example 1

                                                                                                                                                                                                                                                                                                                                  var sessionsRef = firebase.database().ref("sessions");
                                                                                                                                                                                                                                                                                                                                  sessionsRef.push({
                                                                                                                                                                                                                                                                                                                                  startedAt: firebase.database.ServerValue.TIMESTAMP
                                                                                                                                                                                                                                                                                                                                  });

                                                                                                                                                                                                                                                                                                                                function increment

                                                                                                                                                                                                                                                                                                                                increment: (delta: number) => Object;
                                                                                                                                                                                                                                                                                                                                • Returns a placeholder value that can be used to atomically increment the current database value by the provided delta.

                                                                                                                                                                                                                                                                                                                                  Parameter delta

                                                                                                                                                                                                                                                                                                                                  the amount to modify the current value atomically. a placeholder value for modifying data atomically server-side.

                                                                                                                                                                                                                                                                                                                                namespace firebase.firestore

                                                                                                                                                                                                                                                                                                                                namespace firebase.firestore {}

                                                                                                                                                                                                                                                                                                                                  variable CACHE_SIZE_UNLIMITED

                                                                                                                                                                                                                                                                                                                                  const CACHE_SIZE_UNLIMITED: number;
                                                                                                                                                                                                                                                                                                                                  • Constant used to indicate the LRU garbage collection should be disabled. Set this value as the cacheSizeBytes on the settings passed to the Firestore instance.

                                                                                                                                                                                                                                                                                                                                  function setLogLevel

                                                                                                                                                                                                                                                                                                                                  setLogLevel: (logLevel: LogLevel) => void;
                                                                                                                                                                                                                                                                                                                                  • Sets the verbosity of Cloud Firestore logs (debug, error, or silent).

                                                                                                                                                                                                                                                                                                                                    Parameter logLevel

                                                                                                                                                                                                                                                                                                                                    The verbosity you set for activity and error logging. Can be any of the following values:

                                                                                                                                                                                                                                                                                                                                    debug for the most verbose logging level, primarily for debugging. error to log errors only. silent to turn off logging.

                                                                                                                                                                                                                                                                                                                                  class Blob

                                                                                                                                                                                                                                                                                                                                  class Blob {}
                                                                                                                                                                                                                                                                                                                                  • An immutable object representing an array of bytes.

                                                                                                                                                                                                                                                                                                                                  method fromBase64String

                                                                                                                                                                                                                                                                                                                                  static fromBase64String: (base64: string) => Blob;
                                                                                                                                                                                                                                                                                                                                  • Creates a new Blob from the given Base64 string, converting it to bytes.

                                                                                                                                                                                                                                                                                                                                    Parameter base64

                                                                                                                                                                                                                                                                                                                                    The Base64 string used to create the Blob object.

                                                                                                                                                                                                                                                                                                                                  method fromUint8Array

                                                                                                                                                                                                                                                                                                                                  static fromUint8Array: (array: Uint8Array) => Blob;
                                                                                                                                                                                                                                                                                                                                  • Creates a new Blob from the given Uint8Array.

                                                                                                                                                                                                                                                                                                                                    Parameter array

                                                                                                                                                                                                                                                                                                                                    The Uint8Array used to create the Blob object.

                                                                                                                                                                                                                                                                                                                                  method isEqual

                                                                                                                                                                                                                                                                                                                                  isEqual: (other: Blob) => boolean;
                                                                                                                                                                                                                                                                                                                                  • Returns true if this Blob is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                    Parameter other

                                                                                                                                                                                                                                                                                                                                    The Blob to compare against. true if this Blob is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                  method toBase64

                                                                                                                                                                                                                                                                                                                                  toBase64: () => string;
                                                                                                                                                                                                                                                                                                                                  • Returns the bytes of a Blob as a Base64-encoded string.

                                                                                                                                                                                                                                                                                                                                    The Base64-encoded string created from the Blob object.

                                                                                                                                                                                                                                                                                                                                  method toUint8Array

                                                                                                                                                                                                                                                                                                                                  toUint8Array: () => Uint8Array;
                                                                                                                                                                                                                                                                                                                                  • Returns the bytes of a Blob in a new Uint8Array.

                                                                                                                                                                                                                                                                                                                                    The Uint8Array created from the Blob object.

                                                                                                                                                                                                                                                                                                                                  class CollectionReference

                                                                                                                                                                                                                                                                                                                                  class CollectionReference<T = DocumentData> extends Query<T> {}
                                                                                                                                                                                                                                                                                                                                  • A CollectionReference object can be used for adding documents, getting document references, and querying for documents (using the methods inherited from Query).

                                                                                                                                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                                                                                                                                  readonly id: string;
                                                                                                                                                                                                                                                                                                                                  • The collection's identifier.

                                                                                                                                                                                                                                                                                                                                  property parent

                                                                                                                                                                                                                                                                                                                                  readonly parent: DocumentReference<DocumentData>;
                                                                                                                                                                                                                                                                                                                                  • A reference to the containing DocumentReference if this is a subcollection. If this isn't a subcollection, the reference is null.

                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                  readonly path: string;
                                                                                                                                                                                                                                                                                                                                  • A string representing the path of the referenced collection (relative to the root of the database).

                                                                                                                                                                                                                                                                                                                                  method add

                                                                                                                                                                                                                                                                                                                                  add: (data: T) => Promise<DocumentReference<T>>;
                                                                                                                                                                                                                                                                                                                                  • Add a new document to this collection with the specified data, assigning it a document ID automatically.

                                                                                                                                                                                                                                                                                                                                    Parameter data

                                                                                                                                                                                                                                                                                                                                    An Object containing the data for the new document. A Promise resolved with a DocumentReference pointing to the newly created document after it has been written to the backend.

                                                                                                                                                                                                                                                                                                                                  method doc

                                                                                                                                                                                                                                                                                                                                  doc: (documentPath?: string) => DocumentReference<T>;
                                                                                                                                                                                                                                                                                                                                  • Get a DocumentReference for the document within the collection at the specified path. If no path is specified, an automatically-generated unique ID will be used for the returned DocumentReference.

                                                                                                                                                                                                                                                                                                                                    Parameter documentPath

                                                                                                                                                                                                                                                                                                                                    A slash-separated path to a document. The DocumentReference instance.

                                                                                                                                                                                                                                                                                                                                  method isEqual

                                                                                                                                                                                                                                                                                                                                  isEqual: (other: CollectionReference<T>) => boolean;
                                                                                                                                                                                                                                                                                                                                  • Returns true if this CollectionReference is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                    Parameter other

                                                                                                                                                                                                                                                                                                                                    The CollectionReference to compare against. true if this CollectionReference is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                  method withConverter

                                                                                                                                                                                                                                                                                                                                  withConverter: {
                                                                                                                                                                                                                                                                                                                                  (converter: null): CollectionReference<DocumentData>;
                                                                                                                                                                                                                                                                                                                                  <U>(converter: FirestoreDataConverter<U>): CollectionReference<U>;
                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                  • Applies a custom data converter to this CollectionReference, allowing you to use your own custom model objects with Firestore. When you call add() on the returned CollectionReference instance, the provided converter will convert between Firestore data and your custom type U.

                                                                                                                                                                                                                                                                                                                                    Passing in null as the converter parameter removes the current converter.

                                                                                                                                                                                                                                                                                                                                    Parameter converter

                                                                                                                                                                                                                                                                                                                                    Converts objects to and from Firestore. Passing in null removes the current converter. A CollectionReference that uses the provided converter.

                                                                                                                                                                                                                                                                                                                                  class DocumentReference

                                                                                                                                                                                                                                                                                                                                  class DocumentReference<T = DocumentData> {}
                                                                                                                                                                                                                                                                                                                                  • A DocumentReference refers to a document location in a Firestore database and can be used to write, read, or listen to the location. The document at the referenced location may or may not exist. A DocumentReference can also be used to create a CollectionReference to a subcollection.

                                                                                                                                                                                                                                                                                                                                  property firestore

                                                                                                                                                                                                                                                                                                                                  readonly firestore: Firestore;

                                                                                                                                                                                                                                                                                                                                  property id

                                                                                                                                                                                                                                                                                                                                  readonly id: string;
                                                                                                                                                                                                                                                                                                                                  • The document's identifier within its collection.

                                                                                                                                                                                                                                                                                                                                  property parent

                                                                                                                                                                                                                                                                                                                                  readonly parent: CollectionReference<T>;
                                                                                                                                                                                                                                                                                                                                  • The Collection this DocumentReference belongs to.

                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                  readonly path: string;
                                                                                                                                                                                                                                                                                                                                  • A string representing the path of the referenced document (relative to the root of the database).

                                                                                                                                                                                                                                                                                                                                  method collection

                                                                                                                                                                                                                                                                                                                                  collection: (collectionPath: string) => CollectionReference<DocumentData>;
                                                                                                                                                                                                                                                                                                                                  • Gets a CollectionReference instance that refers to the collection at the specified path.

                                                                                                                                                                                                                                                                                                                                    Parameter collectionPath

                                                                                                                                                                                                                                                                                                                                    A slash-separated path to a collection. The CollectionReference instance.

                                                                                                                                                                                                                                                                                                                                  method delete

                                                                                                                                                                                                                                                                                                                                  delete: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                  • Deletes the document referred to by this DocumentReference.

                                                                                                                                                                                                                                                                                                                                    A Promise resolved once the document has been successfully deleted from the backend (Note that it won't resolve while you're offline).

                                                                                                                                                                                                                                                                                                                                  method get

                                                                                                                                                                                                                                                                                                                                  get: (options?: GetOptions) => Promise<DocumentSnapshot<T>>;
                                                                                                                                                                                                                                                                                                                                  • Reads the document referred to by this DocumentReference.

                                                                                                                                                                                                                                                                                                                                    Note: By default, get() attempts to provide up-to-date data when possible by waiting for data from the server, but it may return cached data or fail if you are offline and the server cannot be reached. This behavior can be altered via the GetOptions parameter.

                                                                                                                                                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                                                                                                                                                    An object to configure the get behavior. A Promise resolved with a DocumentSnapshot containing the current document contents.

                                                                                                                                                                                                                                                                                                                                  method isEqual

                                                                                                                                                                                                                                                                                                                                  isEqual: (other: DocumentReference<T>) => boolean;
                                                                                                                                                                                                                                                                                                                                  • Returns true if this DocumentReference is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                    Parameter other

                                                                                                                                                                                                                                                                                                                                    The DocumentReference to compare against. true if this DocumentReference is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                  method onSnapshot

                                                                                                                                                                                                                                                                                                                                  onSnapshot: {
                                                                                                                                                                                                                                                                                                                                  (observer: {
                                                                                                                                                                                                                                                                                                                                  next?: (snapshot: DocumentSnapshot<T>) => void;
                                                                                                                                                                                                                                                                                                                                  error?: (error: FirestoreError) => void;
                                                                                                                                                                                                                                                                                                                                  complete?: () => void;
                                                                                                                                                                                                                                                                                                                                  }): () => void;
                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                  options: SnapshotListenOptions,
                                                                                                                                                                                                                                                                                                                                  observer: {
                                                                                                                                                                                                                                                                                                                                  next?: (snapshot: DocumentSnapshot<T>) => void;
                                                                                                                                                                                                                                                                                                                                  error?: (error: FirestoreError) => void;
                                                                                                                                                                                                                                                                                                                                  complete?: () => void;
                                                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                                                  ): () => void;
                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                  onNext: (snapshot: DocumentSnapshot<T>) => void,
                                                                                                                                                                                                                                                                                                                                  onError?: (error: FirestoreError) => void,
                                                                                                                                                                                                                                                                                                                                  onCompletion?: () => void
                                                                                                                                                                                                                                                                                                                                  ): () => void;
                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                  options: SnapshotListenOptions,
                                                                                                                                                                                                                                                                                                                                  onNext: (snapshot: DocumentSnapshot<T>) => void,
                                                                                                                                                                                                                                                                                                                                  onError?: (error: FirestoreError) => void,
                                                                                                                                                                                                                                                                                                                                  onCompletion?: () => void
                                                                                                                                                                                                                                                                                                                                  ): () => void;
                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                  • Attaches a listener for DocumentSnapshot events. You may either pass individual onNext and onError callbacks or pass a single observer object with next and error callbacks.

                                                                                                                                                                                                                                                                                                                                    NOTE: Although an onCompletion callback can be provided, it will never be called because the snapshot stream is never-ending.

                                                                                                                                                                                                                                                                                                                                    Parameter observer

                                                                                                                                                                                                                                                                                                                                    A single object containing next and error callbacks. An unsubscribe function that can be called to cancel the snapshot listener.

                                                                                                                                                                                                                                                                                                                                  • Attaches a listener for DocumentSnapshot events. You may either pass individual onNext and onError callbacks or pass a single observer object with next and error callbacks.

                                                                                                                                                                                                                                                                                                                                    NOTE: Although an onCompletion callback can be provided, it will never be called because the snapshot stream is never-ending.

                                                                                                                                                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                                                                                                                                                    Options controlling the listen behavior.

                                                                                                                                                                                                                                                                                                                                    Parameter observer

                                                                                                                                                                                                                                                                                                                                    A single object containing next and error callbacks. An unsubscribe function that can be called to cancel the snapshot listener.

                                                                                                                                                                                                                                                                                                                                  • Attaches a listener for DocumentSnapshot events. You may either pass individual onNext and onError callbacks or pass a single observer object with next and error callbacks.

                                                                                                                                                                                                                                                                                                                                    NOTE: Although an onCompletion callback can be provided, it will never be called because the snapshot stream is never-ending.

                                                                                                                                                                                                                                                                                                                                    Parameter onNext

                                                                                                                                                                                                                                                                                                                                    A callback to be called every time a new DocumentSnapshot is available.

                                                                                                                                                                                                                                                                                                                                    Parameter onError

                                                                                                                                                                                                                                                                                                                                    A callback to be called if the listen fails or is cancelled. No further callbacks will occur. An unsubscribe function that can be called to cancel the snapshot listener.

                                                                                                                                                                                                                                                                                                                                  • Attaches a listener for DocumentSnapshot events. You may either pass individual onNext and onError callbacks or pass a single observer object with next and error callbacks.

                                                                                                                                                                                                                                                                                                                                    NOTE: Although an onCompletion callback can be provided, it will never be called because the snapshot stream is never-ending.

                                                                                                                                                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                                                                                                                                                    Options controlling the listen behavior.

                                                                                                                                                                                                                                                                                                                                    Parameter onNext

                                                                                                                                                                                                                                                                                                                                    A callback to be called every time a new DocumentSnapshot is available.

                                                                                                                                                                                                                                                                                                                                    Parameter onError

                                                                                                                                                                                                                                                                                                                                    A callback to be called if the listen fails or is cancelled. No further callbacks will occur. An unsubscribe function that can be called to cancel the snapshot listener.

                                                                                                                                                                                                                                                                                                                                  method set

                                                                                                                                                                                                                                                                                                                                  set: {
                                                                                                                                                                                                                                                                                                                                  (data: Partial<T>, options: SetOptions): Promise<void>;
                                                                                                                                                                                                                                                                                                                                  (data: T): Promise<void>;
                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                  • Writes to the document referred to by this DocumentReference. If the document does not yet exist, it will be created. If you pass SetOptions, the provided data can be merged into an existing document.

                                                                                                                                                                                                                                                                                                                                    Parameter data

                                                                                                                                                                                                                                                                                                                                    A map of the fields and values for the document.

                                                                                                                                                                                                                                                                                                                                    Parameter options

                                                                                                                                                                                                                                                                                                                                    An object to configure the set behavior. A Promise resolved once the data has been successfully written to the backend (Note that it won't resolve while you're offline).

                                                                                                                                                                                                                                                                                                                                  • Writes to the document referred to by this DocumentReference. If the document does not yet exist, it will be created. If you pass SetOptions, the provided data can be merged into an existing document.

                                                                                                                                                                                                                                                                                                                                    Parameter data

                                                                                                                                                                                                                                                                                                                                    A map of the fields and values for the document. A Promise resolved once the data has been successfully written to the backend (Note that it won't resolve while you're offline).

                                                                                                                                                                                                                                                                                                                                  method update

                                                                                                                                                                                                                                                                                                                                  update: {
                                                                                                                                                                                                                                                                                                                                  (data: UpdateData): Promise<void>;
                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                  field: string | FieldPath,
                                                                                                                                                                                                                                                                                                                                  value: any,
                                                                                                                                                                                                                                                                                                                                  ...moreFieldsAndValues: any[]
                                                                                                                                                                                                                                                                                                                                  ): Promise<void>;
                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                  • Updates fields in the document referred to by this DocumentReference. The update will fail if applied to a document that does not exist.

                                                                                                                                                                                                                                                                                                                                    Parameter data

                                                                                                                                                                                                                                                                                                                                    An object containing the fields and values with which to update the document. Fields can contain dots to reference nested fields within the document. A Promise resolved once the data has been successfully written to the backend (Note that it won't resolve while you're offline).

                                                                                                                                                                                                                                                                                                                                  • Updates fields in the document referred to by this DocumentReference. The update will fail if applied to a document that does not exist.

                                                                                                                                                                                                                                                                                                                                    Nested fields can be updated by providing dot-separated field path strings or by providing FieldPath objects.

                                                                                                                                                                                                                                                                                                                                    Parameter field

                                                                                                                                                                                                                                                                                                                                    The first field to update.

                                                                                                                                                                                                                                                                                                                                    Parameter value

                                                                                                                                                                                                                                                                                                                                    The first value.

                                                                                                                                                                                                                                                                                                                                    Parameter moreFieldsAndValues

                                                                                                                                                                                                                                                                                                                                    Additional key value pairs. A Promise resolved once the data has been successfully written to the backend (Note that it won't resolve while you're offline).

                                                                                                                                                                                                                                                                                                                                  method withConverter

                                                                                                                                                                                                                                                                                                                                  withConverter: {
                                                                                                                                                                                                                                                                                                                                  (converter: null): DocumentReference<DocumentData>;
                                                                                                                                                                                                                                                                                                                                  <U>(converter: FirestoreDataConverter<U>): DocumentReference<U>;
                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                  • Applies a custom data converter to this DocumentReference, allowing you to use your own custom model objects with Firestore. When you call set(), get(), etc. on the returned DocumentReference instance, the provided converter will convert between Firestore data and your custom type U.

                                                                                                                                                                                                                                                                                                                                    Passing in null as the converter parameter removes the current converter.

                                                                                                                                                                                                                                                                                                                                    Parameter converter

                                                                                                                                                                                                                                                                                                                                    Converts objects to and from Firestore. Passing in null removes the current converter. A DocumentReference that uses the provided converter.

                                                                                                                                                                                                                                                                                                                                  class DocumentSnapshot

                                                                                                                                                                                                                                                                                                                                  class DocumentSnapshot<T = DocumentData> {}
                                                                                                                                                                                                                                                                                                                                  • A DocumentSnapshot contains data read from a document in your Firestore database. The data can be extracted with .data() or .get(<field>) to get a specific field.

                                                                                                                                                                                                                                                                                                                                    For a DocumentSnapshot that points to a non-existing document, any data access will return 'undefined'. You can use the exists property to explicitly verify a document's existence.

                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                  protected constructor();

                                                                                                                                                                                                                                                                                                                                    property exists

                                                                                                                                                                                                                                                                                                                                    readonly exists: boolean;
                                                                                                                                                                                                                                                                                                                                    • Property of the DocumentSnapshot that signals whether or not the data exists. True if the document exists.

                                                                                                                                                                                                                                                                                                                                    property id

                                                                                                                                                                                                                                                                                                                                    readonly id: string;
                                                                                                                                                                                                                                                                                                                                    • Property of the DocumentSnapshot that provides the document's ID.

                                                                                                                                                                                                                                                                                                                                    property metadata

                                                                                                                                                                                                                                                                                                                                    readonly metadata: SnapshotMetadata;
                                                                                                                                                                                                                                                                                                                                    • Metadata about the DocumentSnapshot, including information about its source and local modifications.

                                                                                                                                                                                                                                                                                                                                    property ref

                                                                                                                                                                                                                                                                                                                                    readonly ref: DocumentReference<T>;
                                                                                                                                                                                                                                                                                                                                    • The DocumentReference for the document included in the DocumentSnapshot.

                                                                                                                                                                                                                                                                                                                                    method data

                                                                                                                                                                                                                                                                                                                                    data: (options?: SnapshotOptions) => T | undefined;
                                                                                                                                                                                                                                                                                                                                    • Retrieves all fields in the document as an Object. Returns 'undefined' if the document doesn't exist.

                                                                                                                                                                                                                                                                                                                                      By default, FieldValue.serverTimestamp() values that have not yet been set to their final value will be returned as null. You can override this by passing an options object.

                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                      An options object to configure how data is retrieved from the snapshot (e.g. the desired behavior for server timestamps that have not yet been set to their final value). An Object containing all fields in the document or 'undefined' if the document doesn't exist.

                                                                                                                                                                                                                                                                                                                                    method get

                                                                                                                                                                                                                                                                                                                                    get: (fieldPath: string | FieldPath, options?: SnapshotOptions) => any;
                                                                                                                                                                                                                                                                                                                                    • Retrieves the field specified by fieldPath. Returns undefined if the document or field doesn't exist.

                                                                                                                                                                                                                                                                                                                                      By default, a FieldValue.serverTimestamp() that has not yet been set to its final value will be returned as null. You can override this by passing an options object.

                                                                                                                                                                                                                                                                                                                                      Parameter fieldPath

                                                                                                                                                                                                                                                                                                                                      The path (e.g. 'foo' or 'foo.bar') to a specific field.

                                                                                                                                                                                                                                                                                                                                      Parameter options

                                                                                                                                                                                                                                                                                                                                      An options object to configure how the field is retrieved from the snapshot (e.g. the desired behavior for server timestamps that have not yet been set to their final value). The data at the specified field location or undefined if no such field exists in the document.

                                                                                                                                                                                                                                                                                                                                    method isEqual

                                                                                                                                                                                                                                                                                                                                    isEqual: (other: DocumentSnapshot<T>) => boolean;
                                                                                                                                                                                                                                                                                                                                    • Returns true if this DocumentSnapshot is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                      Parameter other

                                                                                                                                                                                                                                                                                                                                      The DocumentSnapshot to compare against. true if this DocumentSnapshot is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                    class FieldPath

                                                                                                                                                                                                                                                                                                                                    class FieldPath {}
                                                                                                                                                                                                                                                                                                                                    • A FieldPath refers to a field in a document. The path may consist of a single field name (referring to a top-level field in the document), or a list of field names (referring to a nested field in the document).

                                                                                                                                                                                                                                                                                                                                      Create a FieldPath by providing field names. If more than one field name is provided, the path will point to a nested field in a document.

                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                    constructor(...fieldNames: string[]);
                                                                                                                                                                                                                                                                                                                                    • Creates a FieldPath from the provided field names. If more than one field name is provided, the path will point to a nested field in a document.

                                                                                                                                                                                                                                                                                                                                      Parameter fieldNames

                                                                                                                                                                                                                                                                                                                                      A list of field names.

                                                                                                                                                                                                                                                                                                                                    method documentId

                                                                                                                                                                                                                                                                                                                                    static documentId: () => FieldPath;
                                                                                                                                                                                                                                                                                                                                    • Returns a special sentinel FieldPath to refer to the ID of a document. It can be used in queries to sort or filter by the document ID.

                                                                                                                                                                                                                                                                                                                                    method isEqual

                                                                                                                                                                                                                                                                                                                                    isEqual: (other: FieldPath) => boolean;
                                                                                                                                                                                                                                                                                                                                    • Returns true if this FieldPath is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                      Parameter other

                                                                                                                                                                                                                                                                                                                                      The FieldPath to compare against. true if this FieldPath is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                    class FieldValue

                                                                                                                                                                                                                                                                                                                                    class FieldValue {}
                                                                                                                                                                                                                                                                                                                                    • Sentinel values that can be used when writing document fields with set() or update().

                                                                                                                                                                                                                                                                                                                                    method arrayRemove

                                                                                                                                                                                                                                                                                                                                    static arrayRemove: (...elements: any[]) => FieldValue;
                                                                                                                                                                                                                                                                                                                                    • Returns a special value that can be used with set() or update() that tells the server to remove the given elements from any array value that already exists on the server. All instances of each element specified will be removed from the array. If the field being modified is not already an array it will be overwritten with an empty array.

                                                                                                                                                                                                                                                                                                                                      Parameter elements

                                                                                                                                                                                                                                                                                                                                      The elements to remove from the array. The FieldValue sentinel for use in a call to set() or update().

                                                                                                                                                                                                                                                                                                                                    method arrayUnion

                                                                                                                                                                                                                                                                                                                                    static arrayUnion: (...elements: any[]) => FieldValue;
                                                                                                                                                                                                                                                                                                                                    • Returns a special value that can be used with set() or update() that tells the server to union the given elements with any array value that already exists on the server. Each specified element that doesn't already exist in the array will be added to the end. If the field being modified is not already an array it will be overwritten with an array containing exactly the specified elements.

                                                                                                                                                                                                                                                                                                                                      Parameter elements

                                                                                                                                                                                                                                                                                                                                      The elements to union into the array. The FieldValue sentinel for use in a call to set() or update().

                                                                                                                                                                                                                                                                                                                                    method delete

                                                                                                                                                                                                                                                                                                                                    static delete: () => FieldValue;
                                                                                                                                                                                                                                                                                                                                    • Returns a sentinel for use with update() to mark a field for deletion.

                                                                                                                                                                                                                                                                                                                                    method increment

                                                                                                                                                                                                                                                                                                                                    static increment: (n: number) => FieldValue;
                                                                                                                                                                                                                                                                                                                                    • Returns a special value that can be used with set() or update() that tells the server to increment the field's current value by the given value.

                                                                                                                                                                                                                                                                                                                                      If either the operand or the current field value uses floating point precision, all arithmetic follows IEEE 754 semantics. If both values are integers, values outside of JavaScript's safe number range (Number.MIN_SAFE_INTEGER to Number.MAX_SAFE_INTEGER) are also subject to precision loss. Furthermore, once processed by the Firestore backend, all integer operations are capped between -2^63 and 2^63-1.

                                                                                                                                                                                                                                                                                                                                      If the current field value is not of type number, or if the field does not yet exist, the transformation sets the field to the given value.

                                                                                                                                                                                                                                                                                                                                      Parameter n

                                                                                                                                                                                                                                                                                                                                      The value to increment by. The FieldValue sentinel for use in a call to set() or update().

                                                                                                                                                                                                                                                                                                                                    method isEqual

                                                                                                                                                                                                                                                                                                                                    isEqual: (other: FieldValue) => boolean;
                                                                                                                                                                                                                                                                                                                                    • Returns true if this FieldValue is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                      Parameter other

                                                                                                                                                                                                                                                                                                                                      The FieldValue to compare against. true if this FieldValue is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                    method serverTimestamp

                                                                                                                                                                                                                                                                                                                                    static serverTimestamp: () => FieldValue;
                                                                                                                                                                                                                                                                                                                                    • Returns a sentinel used with set() or update() to include a server-generated timestamp in the written data.

                                                                                                                                                                                                                                                                                                                                    class Firestore

                                                                                                                                                                                                                                                                                                                                    class Firestore {}
                                                                                                                                                                                                                                                                                                                                    • The Cloud Firestore service interface.

                                                                                                                                                                                                                                                                                                                                      Do not call this constructor directly. Instead, use .

                                                                                                                                                                                                                                                                                                                                    property app

                                                                                                                                                                                                                                                                                                                                    app: app.App;
                                                                                                                                                                                                                                                                                                                                    • The associated with this Firestore service instance.

                                                                                                                                                                                                                                                                                                                                    property INTERNAL

                                                                                                                                                                                                                                                                                                                                    INTERNAL: { delete: () => Promise<void> };

                                                                                                                                                                                                                                                                                                                                    method batch

                                                                                                                                                                                                                                                                                                                                    batch: () => WriteBatch;
                                                                                                                                                                                                                                                                                                                                    • Creates a write batch, used for performing multiple writes as a single atomic operation. The maximum number of writes allowed in a single WriteBatch is 500, but note that each usage of FieldValue.serverTimestamp(), FieldValue.arrayUnion(), FieldValue.arrayRemove(), or FieldValue.increment() inside a WriteBatch counts as an additional write.

                                                                                                                                                                                                                                                                                                                                      A WriteBatch that can be used to atomically execute multiple writes.

                                                                                                                                                                                                                                                                                                                                    method clearPersistence

                                                                                                                                                                                                                                                                                                                                    clearPersistence: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                    • Clears the persistent storage. This includes pending writes and cached documents.

                                                                                                                                                                                                                                                                                                                                      Must be called while the firestore instance is not started (after the app is shutdown or when the app is first initialized). On startup, this method must be called before other methods (other than settings()). If the firestore instance is still running, the promise will be rejected with the error code of failed-precondition.

                                                                                                                                                                                                                                                                                                                                      Note: clearPersistence() is primarily intended to help write reliable tests that use Cloud Firestore. It uses an efficient mechanism for dropping existing data but does not attempt to securely overwrite or otherwise make cached data unrecoverable. For applications that are sensitive to the disclosure of cached data in between user sessions, we strongly recommend not enabling persistence at all.

                                                                                                                                                                                                                                                                                                                                      A promise that is resolved when the persistent storage is cleared. Otherwise, the promise is rejected with an error.

                                                                                                                                                                                                                                                                                                                                    method collection

                                                                                                                                                                                                                                                                                                                                    collection: (collectionPath: string) => CollectionReference<DocumentData>;
                                                                                                                                                                                                                                                                                                                                    • Gets a CollectionReference instance that refers to the collection at the specified path.

                                                                                                                                                                                                                                                                                                                                      Parameter collectionPath

                                                                                                                                                                                                                                                                                                                                      A slash-separated path to a collection. The CollectionReference instance.

                                                                                                                                                                                                                                                                                                                                    method collectionGroup

                                                                                                                                                                                                                                                                                                                                    collectionGroup: (collectionId: string) => Query<DocumentData>;
                                                                                                                                                                                                                                                                                                                                    • Creates and returns a new Query that includes all documents in the database that are contained in a collection or subcollection with the given collectionId.

                                                                                                                                                                                                                                                                                                                                      Parameter collectionId

                                                                                                                                                                                                                                                                                                                                      Identifies the collections to query over. Every collection or subcollection with this ID as the last segment of its path will be included. Cannot contain a slash. The created Query.

                                                                                                                                                                                                                                                                                                                                    method disableNetwork

                                                                                                                                                                                                                                                                                                                                    disableNetwork: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                    • Disables network usage for this instance. It can be re-enabled via . While the network is disabled, any snapshot listeners or get() calls will return results from cache, and any write operations will be queued until the network is restored.

                                                                                                                                                                                                                                                                                                                                      A promise that is resolved once the network has been disabled.

                                                                                                                                                                                                                                                                                                                                    method doc

                                                                                                                                                                                                                                                                                                                                    doc: (documentPath: string) => DocumentReference<DocumentData>;
                                                                                                                                                                                                                                                                                                                                    • Gets a DocumentReference instance that refers to the document at the specified path.

                                                                                                                                                                                                                                                                                                                                      Parameter documentPath

                                                                                                                                                                                                                                                                                                                                      A slash-separated path to a document. The DocumentReference instance.

                                                                                                                                                                                                                                                                                                                                    method enableNetwork

                                                                                                                                                                                                                                                                                                                                    enableNetwork: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                    • Re-enables use of the network for this Firestore instance after a prior call to .

                                                                                                                                                                                                                                                                                                                                      A promise that is resolved once the network has been enabled.

                                                                                                                                                                                                                                                                                                                                    method enablePersistence

                                                                                                                                                                                                                                                                                                                                    enablePersistence: (settings?: PersistenceSettings) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                    • Attempts to enable persistent storage, if possible.

                                                                                                                                                                                                                                                                                                                                      Must be called before any other methods (other than settings() and clearPersistence()).

                                                                                                                                                                                                                                                                                                                                      If this fails, enablePersistence() will reject the promise it returns. Note that even after this failure, the firestore instance will remain usable, however offline persistence will be disabled.

                                                                                                                                                                                                                                                                                                                                      There are several reasons why this can fail, which can be identified by the code on the error.

                                                                                                                                                                                                                                                                                                                                      * failed-precondition: The app is already open in another browser tab. * unimplemented: The browser is incompatible with the offline persistence implementation.

                                                                                                                                                                                                                                                                                                                                      Parameter settings

                                                                                                                                                                                                                                                                                                                                      Optional settings object to configure persistence. A promise that represents successfully enabling persistent storage.

                                                                                                                                                                                                                                                                                                                                    method loadBundle

                                                                                                                                                                                                                                                                                                                                    loadBundle: (
                                                                                                                                                                                                                                                                                                                                    bundleData: ArrayBuffer | ReadableStream<Uint8Array> | string
                                                                                                                                                                                                                                                                                                                                    ) => LoadBundleTask;
                                                                                                                                                                                                                                                                                                                                    • Loads a Firestore bundle into the local cache.

                                                                                                                                                                                                                                                                                                                                      Parameter bundleData

                                                                                                                                                                                                                                                                                                                                      An object representing the bundle to be loaded. Valid objects are ArrayBuffer, ReadableStream<Uint8Array> or string.

                                                                                                                                                                                                                                                                                                                                      A LoadBundleTask object, which notifies callers with progress updates, and completion or error events. It can be used as a Promise<LoadBundleTaskProgress>.

                                                                                                                                                                                                                                                                                                                                    method namedQuery

                                                                                                                                                                                                                                                                                                                                    namedQuery: (name: string) => Promise<Query<DocumentData>>;
                                                                                                                                                                                                                                                                                                                                    • Reads a Firestore Query from local cache, identified by the given name.

                                                                                                                                                                                                                                                                                                                                      The named queries are packaged into bundles on the server side (along with resulting documents), and loaded to local cache using loadBundle. Once in local cache, use this method to extract a Query by name.

                                                                                                                                                                                                                                                                                                                                    method onSnapshotsInSync

                                                                                                                                                                                                                                                                                                                                    onSnapshotsInSync: {
                                                                                                                                                                                                                                                                                                                                    (observer: {
                                                                                                                                                                                                                                                                                                                                    next?: (value: void) => void;
                                                                                                                                                                                                                                                                                                                                    error?: (error: FirestoreError) => void;
                                                                                                                                                                                                                                                                                                                                    complete?: () => void;
                                                                                                                                                                                                                                                                                                                                    }): () => void;
                                                                                                                                                                                                                                                                                                                                    (onSync: () => void): () => void;
                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                    • Attaches a listener for a snapshots-in-sync event. The snapshots-in-sync event indicates that all listeners affected by a given change have fired, even if a single server-generated change affects multiple listeners.

                                                                                                                                                                                                                                                                                                                                      NOTE: The snapshots-in-sync event only indicates that listeners are in sync with each other, but does not relate to whether those snapshots are in sync with the server. Use SnapshotMetadata in the individual listeners to determine if a snapshot is from the cache or the server.

                                                                                                                                                                                                                                                                                                                                      Parameter observer

                                                                                                                                                                                                                                                                                                                                      A single object containing next and error callbacks. An unsubscribe function that can be called to cancel the snapshot listener.

                                                                                                                                                                                                                                                                                                                                    • Attaches a listener for a snapshots-in-sync event. The snapshots-in-sync event indicates that all listeners affected by a given change have fired, even if a single server-generated change affects multiple listeners.

                                                                                                                                                                                                                                                                                                                                      NOTE: The snapshots-in-sync event only indicates that listeners are in sync with each other, but does not relate to whether those snapshots are in sync with the server. Use SnapshotMetadata in the individual listeners to determine if a snapshot is from the cache or the server.

                                                                                                                                                                                                                                                                                                                                      Parameter onSync

                                                                                                                                                                                                                                                                                                                                      A callback to be called every time all snapshot listeners are in sync with each other. An unsubscribe function that can be called to cancel the snapshot listener.

                                                                                                                                                                                                                                                                                                                                    method runTransaction

                                                                                                                                                                                                                                                                                                                                    runTransaction: <T>(
                                                                                                                                                                                                                                                                                                                                    updateFunction: (transaction: Transaction) => Promise<T>
                                                                                                                                                                                                                                                                                                                                    ) => Promise<T>;
                                                                                                                                                                                                                                                                                                                                    • Executes the given updateFunction and then attempts to commit the changes applied within the transaction. If any document read within the transaction has changed, Cloud Firestore retries the updateFunction. If it fails to commit after 5 attempts, the transaction fails.

                                                                                                                                                                                                                                                                                                                                      The maximum number of writes allowed in a single transaction is 500, but note that each usage of FieldValue.serverTimestamp(), FieldValue.arrayUnion(), FieldValue.arrayRemove(), or FieldValue.increment() inside a transaction counts as an additional write.

                                                                                                                                                                                                                                                                                                                                      Parameter updateFunction

                                                                                                                                                                                                                                                                                                                                      The function to execute within the transaction context.

                                                                                                                                                                                                                                                                                                                                      If the transaction completed successfully or was explicitly aborted (the updateFunction returned a failed promise), the promise returned by the updateFunction is returned here. Else, if the transaction failed, a rejected promise with the corresponding failure error will be returned.

                                                                                                                                                                                                                                                                                                                                    method settings

                                                                                                                                                                                                                                                                                                                                    settings: (settings: Settings) => void;
                                                                                                                                                                                                                                                                                                                                    • Specifies custom settings to be used to configure the Firestore instance. Must be set before invoking any other methods.

                                                                                                                                                                                                                                                                                                                                      Parameter settings

                                                                                                                                                                                                                                                                                                                                      The settings to use.

                                                                                                                                                                                                                                                                                                                                    method terminate

                                                                                                                                                                                                                                                                                                                                    terminate: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                    • Terminates this Firestore instance.

                                                                                                                                                                                                                                                                                                                                      After calling terminate() only the clearPersistence() method may be used. Any other method will throw a FirestoreError.

                                                                                                                                                                                                                                                                                                                                      To restart after termination, create a new instance of FirebaseFirestore with firebase.firestore().

                                                                                                                                                                                                                                                                                                                                      Termination does not cancel any pending writes, and any promises that are awaiting a response from the server will not be resolved. If you have persistence enabled, the next time you start this instance, it will resume sending these writes to the server.

                                                                                                                                                                                                                                                                                                                                      Note: Under normal circumstances, calling terminate() is not required. This method is useful only when you want to force this instance to release all of its resources or in combination with clearPersistence() to ensure that all local state is destroyed between test runs.

                                                                                                                                                                                                                                                                                                                                      A promise that is resolved when the instance has been successfully terminated.

                                                                                                                                                                                                                                                                                                                                    method useEmulator

                                                                                                                                                                                                                                                                                                                                    useEmulator: (
                                                                                                                                                                                                                                                                                                                                    host: string,
                                                                                                                                                                                                                                                                                                                                    port: number,
                                                                                                                                                                                                                                                                                                                                    options?: { mockUserToken?: EmulatorMockTokenOptions | string }
                                                                                                                                                                                                                                                                                                                                    ) => void;
                                                                                                                                                                                                                                                                                                                                    • Modify this instance to communicate with the Cloud Firestore emulator.

                                                                                                                                                                                                                                                                                                                                      Note: this must be called before this instance has been used to do any operations.

                                                                                                                                                                                                                                                                                                                                      Parameter host

                                                                                                                                                                                                                                                                                                                                      the emulator host (ex: localhost).

                                                                                                                                                                                                                                                                                                                                      Parameter port

                                                                                                                                                                                                                                                                                                                                      the emulator port (ex: 9000).

                                                                                                                                                                                                                                                                                                                                      Parameter

                                                                                                                                                                                                                                                                                                                                      options.mockUserToken - the mock auth token to use for unit testing Security Rules.

                                                                                                                                                                                                                                                                                                                                    method waitForPendingWrites

                                                                                                                                                                                                                                                                                                                                    waitForPendingWrites: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                    • Waits until all currently pending writes for the active user have been acknowledged by the backend.

                                                                                                                                                                                                                                                                                                                                      The returned Promise resolves immediately if there are no outstanding writes. Otherwise, the Promise waits for all previously issued writes (including those written in a previous app session), but it does not wait for writes that were added after the method is called. If you want to wait for additional writes, call waitForPendingWrites() again.

                                                                                                                                                                                                                                                                                                                                      Any outstanding waitForPendingWrites() Promises are rejected during user changes.

                                                                                                                                                                                                                                                                                                                                      A Promise which resolves when all currently pending writes have been acknowledged by the backend.

                                                                                                                                                                                                                                                                                                                                    class GeoPoint

                                                                                                                                                                                                                                                                                                                                    class GeoPoint {}
                                                                                                                                                                                                                                                                                                                                    • An immutable object representing a geo point in Firestore. The geo point is represented as latitude/longitude pair.

                                                                                                                                                                                                                                                                                                                                      Latitude values are in the range of [-90, 90]. Longitude values are in the range of [-180, 180].

                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                    constructor(latitude: number, longitude: number);
                                                                                                                                                                                                                                                                                                                                    • Creates a new immutable GeoPoint object with the provided latitude and longitude values.

                                                                                                                                                                                                                                                                                                                                      Parameter latitude

                                                                                                                                                                                                                                                                                                                                      The latitude as number between -90 and 90.

                                                                                                                                                                                                                                                                                                                                      Parameter longitude

                                                                                                                                                                                                                                                                                                                                      The longitude as number between -180 and 180.

                                                                                                                                                                                                                                                                                                                                    property latitude

                                                                                                                                                                                                                                                                                                                                    readonly latitude: number;
                                                                                                                                                                                                                                                                                                                                    • The latitude of this GeoPoint instance.

                                                                                                                                                                                                                                                                                                                                    property longitude

                                                                                                                                                                                                                                                                                                                                    readonly longitude: number;
                                                                                                                                                                                                                                                                                                                                    • The longitude of this GeoPoint instance.

                                                                                                                                                                                                                                                                                                                                    method isEqual

                                                                                                                                                                                                                                                                                                                                    isEqual: (other: GeoPoint) => boolean;
                                                                                                                                                                                                                                                                                                                                    • Returns true if this GeoPoint is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                      Parameter other

                                                                                                                                                                                                                                                                                                                                      The GeoPoint to compare against. true if this GeoPoint is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                    class Query

                                                                                                                                                                                                                                                                                                                                    class Query<T = DocumentData> {}
                                                                                                                                                                                                                                                                                                                                    • A Query refers to a Query which you can read or listen to. You can also construct refined Query objects by adding filters and ordering.

                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                    protected constructor();

                                                                                                                                                                                                                                                                                                                                      property firestore

                                                                                                                                                                                                                                                                                                                                      readonly firestore: Firestore;
                                                                                                                                                                                                                                                                                                                                      • The Firestore for the Firestore database (useful for performing transactions, etc.).

                                                                                                                                                                                                                                                                                                                                      method endAt

                                                                                                                                                                                                                                                                                                                                      endAt: {
                                                                                                                                                                                                                                                                                                                                      (snapshot: DocumentSnapshot<any>): Query<T>;
                                                                                                                                                                                                                                                                                                                                      (...fieldValues: any[]): Query<T>;
                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                      • Creates and returns a new Query that ends at the provided document (inclusive). The end position is relative to the order of the query. The document must contain all of the fields provided in the orderBy of this query.

                                                                                                                                                                                                                                                                                                                                        Parameter snapshot

                                                                                                                                                                                                                                                                                                                                        The snapshot of the document to end at. The created Query.

                                                                                                                                                                                                                                                                                                                                      • Creates and returns a new Query that ends at the provided fields relative to the order of the query. The order of the field values must match the order of the order by clauses of the query.

                                                                                                                                                                                                                                                                                                                                        Parameter fieldValues

                                                                                                                                                                                                                                                                                                                                        The field values to end this query at, in order of the query's order by. The created Query.

                                                                                                                                                                                                                                                                                                                                      method endBefore

                                                                                                                                                                                                                                                                                                                                      endBefore: {
                                                                                                                                                                                                                                                                                                                                      (snapshot: DocumentSnapshot<any>): Query<T>;
                                                                                                                                                                                                                                                                                                                                      (...fieldValues: any[]): Query<T>;
                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                      • Creates and returns a new Query that ends before the provided document (exclusive). The end position is relative to the order of the query. The document must contain all of the fields provided in the orderBy of this query.

                                                                                                                                                                                                                                                                                                                                        Parameter snapshot

                                                                                                                                                                                                                                                                                                                                        The snapshot of the document to end before. The created Query.

                                                                                                                                                                                                                                                                                                                                      • Creates and returns a new Query that ends before the provided fields relative to the order of the query. The order of the field values must match the order of the order by clauses of the query.

                                                                                                                                                                                                                                                                                                                                        Parameter fieldValues

                                                                                                                                                                                                                                                                                                                                        The field values to end this query before, in order of the query's order by. The created Query.

                                                                                                                                                                                                                                                                                                                                      method get

                                                                                                                                                                                                                                                                                                                                      get: (options?: GetOptions) => Promise<QuerySnapshot<T>>;
                                                                                                                                                                                                                                                                                                                                      • Executes the query and returns the results as a QuerySnapshot.

                                                                                                                                                                                                                                                                                                                                        Note: By default, get() attempts to provide up-to-date data when possible by waiting for data from the server, but it may return cached data or fail if you are offline and the server cannot be reached. This behavior can be altered via the GetOptions parameter.

                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                        An object to configure the get behavior. A Promise that will be resolved with the results of the Query.

                                                                                                                                                                                                                                                                                                                                      method isEqual

                                                                                                                                                                                                                                                                                                                                      isEqual: (other: Query<T>) => boolean;
                                                                                                                                                                                                                                                                                                                                      • Returns true if this Query is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                        Parameter other

                                                                                                                                                                                                                                                                                                                                        The Query to compare against. true if this Query is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                      method limit

                                                                                                                                                                                                                                                                                                                                      limit: (limit: number) => Query<T>;
                                                                                                                                                                                                                                                                                                                                      • Creates and returns a new Query that only returns the first matching documents.

                                                                                                                                                                                                                                                                                                                                        Parameter limit

                                                                                                                                                                                                                                                                                                                                        The maximum number of items to return. The created Query.

                                                                                                                                                                                                                                                                                                                                      method limitToLast

                                                                                                                                                                                                                                                                                                                                      limitToLast: (limit: number) => Query<T>;
                                                                                                                                                                                                                                                                                                                                      • Creates and returns a new Query that only returns the last matching documents.

                                                                                                                                                                                                                                                                                                                                        You must specify at least one orderBy clause for limitToLast queries, otherwise an exception will be thrown during execution.

                                                                                                                                                                                                                                                                                                                                        Parameter limit

                                                                                                                                                                                                                                                                                                                                        The maximum number of items to return. The created Query.

                                                                                                                                                                                                                                                                                                                                      method onSnapshot

                                                                                                                                                                                                                                                                                                                                      onSnapshot: {
                                                                                                                                                                                                                                                                                                                                      (observer: {
                                                                                                                                                                                                                                                                                                                                      next?: (snapshot: QuerySnapshot<T>) => void;
                                                                                                                                                                                                                                                                                                                                      error?: (error: FirestoreError) => void;
                                                                                                                                                                                                                                                                                                                                      complete?: () => void;
                                                                                                                                                                                                                                                                                                                                      }): () => void;
                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                      options: SnapshotListenOptions,
                                                                                                                                                                                                                                                                                                                                      observer: {
                                                                                                                                                                                                                                                                                                                                      next?: (snapshot: QuerySnapshot<T>) => void;
                                                                                                                                                                                                                                                                                                                                      error?: (error: FirestoreError) => void;
                                                                                                                                                                                                                                                                                                                                      complete?: () => void;
                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                      ): () => void;
                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                      onNext: (snapshot: QuerySnapshot<T>) => void,
                                                                                                                                                                                                                                                                                                                                      onError?: (error: FirestoreError) => void,
                                                                                                                                                                                                                                                                                                                                      onCompletion?: () => void
                                                                                                                                                                                                                                                                                                                                      ): () => void;
                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                      options: SnapshotListenOptions,
                                                                                                                                                                                                                                                                                                                                      onNext: (snapshot: QuerySnapshot<T>) => void,
                                                                                                                                                                                                                                                                                                                                      onError?: (error: FirestoreError) => void,
                                                                                                                                                                                                                                                                                                                                      onCompletion?: () => void
                                                                                                                                                                                                                                                                                                                                      ): () => void;
                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                      • Attaches a listener for QuerySnapshot events. You may either pass individual onNext and onError callbacks or pass a single observer object with next and error callbacks. The listener can be cancelled by calling the function that is returned when onSnapshot is called.

                                                                                                                                                                                                                                                                                                                                        NOTE: Although an onCompletion callback can be provided, it will never be called because the snapshot stream is never-ending.

                                                                                                                                                                                                                                                                                                                                        Parameter observer

                                                                                                                                                                                                                                                                                                                                        A single object containing next and error callbacks. An unsubscribe function that can be called to cancel the snapshot listener.

                                                                                                                                                                                                                                                                                                                                      • Attaches a listener for QuerySnapshot events. You may either pass individual onNext and onError callbacks or pass a single observer object with next and error callbacks. The listener can be cancelled by calling the function that is returned when onSnapshot is called.

                                                                                                                                                                                                                                                                                                                                        NOTE: Although an onCompletion callback can be provided, it will never be called because the snapshot stream is never-ending.

                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                        Options controlling the listen behavior.

                                                                                                                                                                                                                                                                                                                                        Parameter observer

                                                                                                                                                                                                                                                                                                                                        A single object containing next and error callbacks. An unsubscribe function that can be called to cancel the snapshot listener.

                                                                                                                                                                                                                                                                                                                                      • Attaches a listener for QuerySnapshot events. You may either pass individual onNext and onError callbacks or pass a single observer object with next and error callbacks. The listener can be cancelled by calling the function that is returned when onSnapshot is called.

                                                                                                                                                                                                                                                                                                                                        NOTE: Although an onCompletion callback can be provided, it will never be called because the snapshot stream is never-ending.

                                                                                                                                                                                                                                                                                                                                        Parameter onNext

                                                                                                                                                                                                                                                                                                                                        A callback to be called every time a new QuerySnapshot is available.

                                                                                                                                                                                                                                                                                                                                        Parameter onError

                                                                                                                                                                                                                                                                                                                                        A callback to be called if the listen fails or is cancelled. No further callbacks will occur. An unsubscribe function that can be called to cancel the snapshot listener.

                                                                                                                                                                                                                                                                                                                                      • Attaches a listener for QuerySnapshot events. You may either pass individual onNext and onError callbacks or pass a single observer object with next and error callbacks. The listener can be cancelled by calling the function that is returned when onSnapshot is called.

                                                                                                                                                                                                                                                                                                                                        NOTE: Although an onCompletion callback can be provided, it will never be called because the snapshot stream is never-ending.

                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                        Options controlling the listen behavior.

                                                                                                                                                                                                                                                                                                                                        Parameter onNext

                                                                                                                                                                                                                                                                                                                                        A callback to be called every time a new QuerySnapshot is available.

                                                                                                                                                                                                                                                                                                                                        Parameter onError

                                                                                                                                                                                                                                                                                                                                        A callback to be called if the listen fails or is cancelled. No further callbacks will occur. An unsubscribe function that can be called to cancel the snapshot listener.

                                                                                                                                                                                                                                                                                                                                      method orderBy

                                                                                                                                                                                                                                                                                                                                      orderBy: (
                                                                                                                                                                                                                                                                                                                                      fieldPath: string | FieldPath,
                                                                                                                                                                                                                                                                                                                                      directionStr?: OrderByDirection
                                                                                                                                                                                                                                                                                                                                      ) => Query<T>;
                                                                                                                                                                                                                                                                                                                                      • Creates and returns a new Query that's additionally sorted by the specified field, optionally in descending order instead of ascending.

                                                                                                                                                                                                                                                                                                                                        Parameter fieldPath

                                                                                                                                                                                                                                                                                                                                        The field to sort by.

                                                                                                                                                                                                                                                                                                                                        Parameter directionStr

                                                                                                                                                                                                                                                                                                                                        Optional direction to sort by (asc or desc). If not specified, order will be ascending. The created Query.

                                                                                                                                                                                                                                                                                                                                      method startAfter

                                                                                                                                                                                                                                                                                                                                      startAfter: {
                                                                                                                                                                                                                                                                                                                                      (snapshot: DocumentSnapshot<any>): Query<T>;
                                                                                                                                                                                                                                                                                                                                      (...fieldValues: any[]): Query<T>;
                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                      • Creates and returns a new Query that starts after the provided document (exclusive). The starting position is relative to the order of the query. The document must contain all of the fields provided in the orderBy of this query.

                                                                                                                                                                                                                                                                                                                                        Parameter snapshot

                                                                                                                                                                                                                                                                                                                                        The snapshot of the document to start after. The created Query.

                                                                                                                                                                                                                                                                                                                                      • Creates and returns a new Query that starts after the provided fields relative to the order of the query. The order of the field values must match the order of the order by clauses of the query.

                                                                                                                                                                                                                                                                                                                                        Parameter fieldValues

                                                                                                                                                                                                                                                                                                                                        The field values to start this query after, in order of the query's order by. The created Query.

                                                                                                                                                                                                                                                                                                                                      method startAt

                                                                                                                                                                                                                                                                                                                                      startAt: {
                                                                                                                                                                                                                                                                                                                                      (snapshot: DocumentSnapshot<any>): Query<T>;
                                                                                                                                                                                                                                                                                                                                      (...fieldValues: any[]): Query<T>;
                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                      • Creates and returns a new Query that starts at the provided document (inclusive). The starting position is relative to the order of the query. The document must contain all of the fields provided in the orderBy of this query.

                                                                                                                                                                                                                                                                                                                                        Parameter snapshot

                                                                                                                                                                                                                                                                                                                                        The snapshot of the document to start at. The created Query.

                                                                                                                                                                                                                                                                                                                                      • Creates and returns a new Query that starts at the provided fields relative to the order of the query. The order of the field values must match the order of the order by clauses of the query.

                                                                                                                                                                                                                                                                                                                                        Parameter fieldValues

                                                                                                                                                                                                                                                                                                                                        The field values to start this query at, in order of the query's order by. The created Query.

                                                                                                                                                                                                                                                                                                                                      method where

                                                                                                                                                                                                                                                                                                                                      where: (
                                                                                                                                                                                                                                                                                                                                      fieldPath: string | FieldPath,
                                                                                                                                                                                                                                                                                                                                      opStr: WhereFilterOp,
                                                                                                                                                                                                                                                                                                                                      value: any
                                                                                                                                                                                                                                                                                                                                      ) => Query<T>;
                                                                                                                                                                                                                                                                                                                                      • Creates and returns a new Query with the additional filter that documents must contain the specified field and the value should satisfy the relation constraint provided.

                                                                                                                                                                                                                                                                                                                                        Parameter fieldPath

                                                                                                                                                                                                                                                                                                                                        The path to compare

                                                                                                                                                                                                                                                                                                                                        Parameter opStr

                                                                                                                                                                                                                                                                                                                                        The operation string (e.g "<", "<=", "==", ">", ">=").

                                                                                                                                                                                                                                                                                                                                        Parameter value

                                                                                                                                                                                                                                                                                                                                        The value for comparison The created Query.

                                                                                                                                                                                                                                                                                                                                      method withConverter

                                                                                                                                                                                                                                                                                                                                      withConverter: {
                                                                                                                                                                                                                                                                                                                                      (converter: null): Query<DocumentData>;
                                                                                                                                                                                                                                                                                                                                      <U>(converter: FirestoreDataConverter<U>): Query<U>;
                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                      • Applies a custom data converter to this Query, allowing you to use your own custom model objects with Firestore. When you call get() on the returned Query, the provided converter will convert between Firestore data and your custom type U.

                                                                                                                                                                                                                                                                                                                                        Passing in null as the converter parameter removes the current converter.

                                                                                                                                                                                                                                                                                                                                        Parameter converter

                                                                                                                                                                                                                                                                                                                                        Converts objects to and from Firestore. Passing in null removes the current converter. A Query that uses the provided converter.

                                                                                                                                                                                                                                                                                                                                      class QueryDocumentSnapshot

                                                                                                                                                                                                                                                                                                                                      class QueryDocumentSnapshot<T = DocumentData> extends DocumentSnapshot<T> {}
                                                                                                                                                                                                                                                                                                                                      • A QueryDocumentSnapshot contains data read from a document in your Firestore database as part of a query. The document is guaranteed to exist and its data can be extracted with .data() or .get(<field>) to get a specific field.

                                                                                                                                                                                                                                                                                                                                        A QueryDocumentSnapshot offers the same API surface as a DocumentSnapshot. Since query results contain only existing documents, the exists property will always be true and data() will never return 'undefined'.

                                                                                                                                                                                                                                                                                                                                      method data

                                                                                                                                                                                                                                                                                                                                      data: (options?: SnapshotOptions) => T;
                                                                                                                                                                                                                                                                                                                                      • Retrieves all fields in the document as an Object.

                                                                                                                                                                                                                                                                                                                                        By default, FieldValue.serverTimestamp() values that have not yet been set to their final value will be returned as null. You can override this by passing an options object.

                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                        An options object to configure how data is retrieved from the snapshot (e.g. the desired behavior for server timestamps that have not yet been set to their final value). An Object containing all fields in the document.

                                                                                                                                                                                                                                                                                                                                        Modifiers

                                                                                                                                                                                                                                                                                                                                        • @override

                                                                                                                                                                                                                                                                                                                                      class QuerySnapshot

                                                                                                                                                                                                                                                                                                                                      class QuerySnapshot<T = DocumentData> {}
                                                                                                                                                                                                                                                                                                                                      • A QuerySnapshot contains zero or more DocumentSnapshot objects representing the results of a query. The documents can be accessed as an array via the docs property or enumerated using the forEach method. The number of documents can be determined via the empty and size properties.

                                                                                                                                                                                                                                                                                                                                      property docs

                                                                                                                                                                                                                                                                                                                                      readonly docs: QueryDocumentSnapshot<T>[];
                                                                                                                                                                                                                                                                                                                                      • An array of all the documents in the QuerySnapshot.

                                                                                                                                                                                                                                                                                                                                      property empty

                                                                                                                                                                                                                                                                                                                                      readonly empty: boolean;
                                                                                                                                                                                                                                                                                                                                      • True if there are no documents in the QuerySnapshot.

                                                                                                                                                                                                                                                                                                                                      property metadata

                                                                                                                                                                                                                                                                                                                                      readonly metadata: SnapshotMetadata;
                                                                                                                                                                                                                                                                                                                                      • Metadata about this snapshot, concerning its source and if it has local modifications.

                                                                                                                                                                                                                                                                                                                                      property query

                                                                                                                                                                                                                                                                                                                                      readonly query: Query<T>;
                                                                                                                                                                                                                                                                                                                                      • The query on which you called get or onSnapshot in order to get this QuerySnapshot.

                                                                                                                                                                                                                                                                                                                                      property size

                                                                                                                                                                                                                                                                                                                                      readonly size: number;
                                                                                                                                                                                                                                                                                                                                      • The number of documents in the QuerySnapshot.

                                                                                                                                                                                                                                                                                                                                      method docChanges

                                                                                                                                                                                                                                                                                                                                      docChanges: (options?: SnapshotListenOptions) => Array<DocumentChange<T>>;
                                                                                                                                                                                                                                                                                                                                      • Returns an array of the documents changes since the last snapshot. If this is the first snapshot, all documents will be in the list as added changes.

                                                                                                                                                                                                                                                                                                                                        Parameter options

                                                                                                                                                                                                                                                                                                                                        SnapshotListenOptions that control whether metadata-only changes (i.e. only DocumentSnapshot.metadata changed) should trigger snapshot events.

                                                                                                                                                                                                                                                                                                                                      method forEach

                                                                                                                                                                                                                                                                                                                                      forEach: (
                                                                                                                                                                                                                                                                                                                                      callback: (result: QueryDocumentSnapshot<T>) => void,
                                                                                                                                                                                                                                                                                                                                      thisArg?: any
                                                                                                                                                                                                                                                                                                                                      ) => void;
                                                                                                                                                                                                                                                                                                                                      • Enumerates all of the documents in the QuerySnapshot.

                                                                                                                                                                                                                                                                                                                                        Parameter callback

                                                                                                                                                                                                                                                                                                                                        A callback to be called with a QueryDocumentSnapshot for each document in the snapshot.

                                                                                                                                                                                                                                                                                                                                        Parameter thisArg

                                                                                                                                                                                                                                                                                                                                        The this binding for the callback.

                                                                                                                                                                                                                                                                                                                                      method isEqual

                                                                                                                                                                                                                                                                                                                                      isEqual: (other: QuerySnapshot<T>) => boolean;
                                                                                                                                                                                                                                                                                                                                      • Returns true if this QuerySnapshot is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                        Parameter other

                                                                                                                                                                                                                                                                                                                                        The QuerySnapshot to compare against. true if this QuerySnapshot is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                      class Timestamp

                                                                                                                                                                                                                                                                                                                                      class Timestamp {}
                                                                                                                                                                                                                                                                                                                                      • A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time.

                                                                                                                                                                                                                                                                                                                                        It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.

                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                        • https://github.com/google/protobuf/blob/master/src/google/protobuf/timestamp.proto

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(seconds: number, nanoseconds: number);
                                                                                                                                                                                                                                                                                                                                      • Creates a new timestamp.

                                                                                                                                                                                                                                                                                                                                        Parameter seconds

                                                                                                                                                                                                                                                                                                                                        The number of seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.

                                                                                                                                                                                                                                                                                                                                        Parameter nanoseconds

                                                                                                                                                                                                                                                                                                                                        The non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanoseconds values that count forward in time. Must be from 0 to 999,999,999 inclusive.

                                                                                                                                                                                                                                                                                                                                      property nanoseconds

                                                                                                                                                                                                                                                                                                                                      readonly nanoseconds: number;

                                                                                                                                                                                                                                                                                                                                        property seconds

                                                                                                                                                                                                                                                                                                                                        readonly seconds: number;

                                                                                                                                                                                                                                                                                                                                          method fromDate

                                                                                                                                                                                                                                                                                                                                          static fromDate: (date: Date) => Timestamp;
                                                                                                                                                                                                                                                                                                                                          • Creates a new timestamp from the given date.

                                                                                                                                                                                                                                                                                                                                            Parameter date

                                                                                                                                                                                                                                                                                                                                            The date to initialize the Timestamp from. A new Timestamp representing the same point in time as the given date.

                                                                                                                                                                                                                                                                                                                                          method fromMillis

                                                                                                                                                                                                                                                                                                                                          static fromMillis: (milliseconds: number) => Timestamp;
                                                                                                                                                                                                                                                                                                                                          • Creates a new timestamp from the given number of milliseconds.

                                                                                                                                                                                                                                                                                                                                            Parameter milliseconds

                                                                                                                                                                                                                                                                                                                                            Number of milliseconds since Unix epoch 1970-01-01T00:00:00Z. A new Timestamp representing the same point in time as the given number of milliseconds.

                                                                                                                                                                                                                                                                                                                                          method isEqual

                                                                                                                                                                                                                                                                                                                                          isEqual: (other: Timestamp) => boolean;
                                                                                                                                                                                                                                                                                                                                          • Returns true if this Timestamp is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                            Parameter other

                                                                                                                                                                                                                                                                                                                                            The Timestamp to compare against. true if this Timestamp is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                          method now

                                                                                                                                                                                                                                                                                                                                          static now: () => Timestamp;
                                                                                                                                                                                                                                                                                                                                          • Creates a new timestamp with the current date, with millisecond precision.

                                                                                                                                                                                                                                                                                                                                            a new timestamp representing the current date.

                                                                                                                                                                                                                                                                                                                                          method toDate

                                                                                                                                                                                                                                                                                                                                          toDate: () => Date;
                                                                                                                                                                                                                                                                                                                                          • Convert a Timestamp to a JavaScript Date object. This conversion causes a loss of precision since Date objects only support millisecond precision.

                                                                                                                                                                                                                                                                                                                                            JavaScript Date object representing the same point in time as this Timestamp, with millisecond precision.

                                                                                                                                                                                                                                                                                                                                          method toMillis

                                                                                                                                                                                                                                                                                                                                          toMillis: () => number;
                                                                                                                                                                                                                                                                                                                                          • Convert a timestamp to a numeric timestamp (in milliseconds since epoch). This operation causes a loss of precision.

                                                                                                                                                                                                                                                                                                                                            The point in time corresponding to this timestamp, represented as the number of milliseconds since Unix epoch 1970-01-01T00:00:00Z.

                                                                                                                                                                                                                                                                                                                                          method valueOf

                                                                                                                                                                                                                                                                                                                                          valueOf: () => string;
                                                                                                                                                                                                                                                                                                                                          • Converts this object to a primitive string, which allows Timestamp objects to be compared using the >, <=, >= and > operators.

                                                                                                                                                                                                                                                                                                                                          class Transaction

                                                                                                                                                                                                                                                                                                                                          class Transaction {}
                                                                                                                                                                                                                                                                                                                                          • A reference to a transaction. The Transaction object passed to a transaction's updateFunction provides the methods to read and write data within the transaction context. See Firestore.runTransaction().

                                                                                                                                                                                                                                                                                                                                          method delete

                                                                                                                                                                                                                                                                                                                                          delete: (documentRef: DocumentReference<any>) => Transaction;
                                                                                                                                                                                                                                                                                                                                          • Deletes the document referred to by the provided DocumentReference.

                                                                                                                                                                                                                                                                                                                                            Parameter documentRef

                                                                                                                                                                                                                                                                                                                                            A reference to the document to be deleted. This Transaction instance. Used for chaining method calls.

                                                                                                                                                                                                                                                                                                                                          method get

                                                                                                                                                                                                                                                                                                                                          get: <T>(documentRef: DocumentReference<T>) => Promise<DocumentSnapshot<T>>;
                                                                                                                                                                                                                                                                                                                                          • Reads the document referenced by the provided DocumentReference.

                                                                                                                                                                                                                                                                                                                                            Parameter documentRef

                                                                                                                                                                                                                                                                                                                                            A reference to the document to be read. A DocumentSnapshot for the read data.

                                                                                                                                                                                                                                                                                                                                          method set

                                                                                                                                                                                                                                                                                                                                          set: {
                                                                                                                                                                                                                                                                                                                                          <T>(
                                                                                                                                                                                                                                                                                                                                          documentRef: DocumentReference<T>,
                                                                                                                                                                                                                                                                                                                                          data: Partial<T>,
                                                                                                                                                                                                                                                                                                                                          options: SetOptions
                                                                                                                                                                                                                                                                                                                                          ): Transaction;
                                                                                                                                                                                                                                                                                                                                          <T>(documentRef: DocumentReference<T>, data: T): Transaction;
                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                          • Writes to the document referred to by the provided DocumentReference. If the document does not exist yet, it will be created. If you pass SetOptions, the provided data can be merged into the existing document.

                                                                                                                                                                                                                                                                                                                                            Parameter documentRef

                                                                                                                                                                                                                                                                                                                                            A reference to the document to be set.

                                                                                                                                                                                                                                                                                                                                            Parameter data

                                                                                                                                                                                                                                                                                                                                            An object of the fields and values for the document.

                                                                                                                                                                                                                                                                                                                                            Parameter options

                                                                                                                                                                                                                                                                                                                                            An object to configure the set behavior. This Transaction instance. Used for chaining method calls.

                                                                                                                                                                                                                                                                                                                                          • Writes to the document referred to by the provided DocumentReference. If the document does not exist yet, it will be created. If you pass SetOptions, the provided data can be merged into the existing document.

                                                                                                                                                                                                                                                                                                                                            Parameter documentRef

                                                                                                                                                                                                                                                                                                                                            A reference to the document to be set.

                                                                                                                                                                                                                                                                                                                                            Parameter data

                                                                                                                                                                                                                                                                                                                                            An object of the fields and values for the document. This Transaction instance. Used for chaining method calls.

                                                                                                                                                                                                                                                                                                                                          method update

                                                                                                                                                                                                                                                                                                                                          update: {
                                                                                                                                                                                                                                                                                                                                          (documentRef: DocumentReference<any>, data: UpdateData): Transaction;
                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                          documentRef: DocumentReference<any>,
                                                                                                                                                                                                                                                                                                                                          field: string | FieldPath,
                                                                                                                                                                                                                                                                                                                                          value: any,
                                                                                                                                                                                                                                                                                                                                          ...moreFieldsAndValues: any[]
                                                                                                                                                                                                                                                                                                                                          ): Transaction;
                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                          • Updates fields in the document referred to by the provided DocumentReference. The update will fail if applied to a document that does not exist.

                                                                                                                                                                                                                                                                                                                                            Parameter documentRef

                                                                                                                                                                                                                                                                                                                                            A reference to the document to be updated.

                                                                                                                                                                                                                                                                                                                                            Parameter data

                                                                                                                                                                                                                                                                                                                                            An object containing the fields and values with which to update the document. Fields can contain dots to reference nested fields within the document. This Transaction instance. Used for chaining method calls.

                                                                                                                                                                                                                                                                                                                                          • Updates fields in the document referred to by the provided DocumentReference. The update will fail if applied to a document that does not exist.

                                                                                                                                                                                                                                                                                                                                            Nested fields can be updated by providing dot-separated field path strings or by providing FieldPath objects.

                                                                                                                                                                                                                                                                                                                                            Parameter documentRef

                                                                                                                                                                                                                                                                                                                                            A reference to the document to be updated.

                                                                                                                                                                                                                                                                                                                                            Parameter field

                                                                                                                                                                                                                                                                                                                                            The first field to update.

                                                                                                                                                                                                                                                                                                                                            Parameter value

                                                                                                                                                                                                                                                                                                                                            The first value.

                                                                                                                                                                                                                                                                                                                                            Parameter moreFieldsAndValues

                                                                                                                                                                                                                                                                                                                                            Additional key/value pairs. A Promise resolved once the data has been successfully written to the backend (Note that it won't resolve while you're offline).

                                                                                                                                                                                                                                                                                                                                          class WriteBatch

                                                                                                                                                                                                                                                                                                                                          class WriteBatch {}
                                                                                                                                                                                                                                                                                                                                          • A write batch, used to perform multiple writes as a single atomic unit.

                                                                                                                                                                                                                                                                                                                                            A WriteBatch object can be acquired by calling Firestore.batch(). It provides methods for adding writes to the write batch. None of the writes will be committed (or visible locally) until WriteBatch.commit() is called.

                                                                                                                                                                                                                                                                                                                                            Unlike transactions, write batches are persisted offline and therefore are preferable when you don't need to condition your writes on read data.

                                                                                                                                                                                                                                                                                                                                          method commit

                                                                                                                                                                                                                                                                                                                                          commit: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                          • Commits all of the writes in this write batch as a single atomic unit.

                                                                                                                                                                                                                                                                                                                                            A Promise resolved once all of the writes in the batch have been successfully written to the backend as an atomic unit. Note that it won't resolve while you're offline.

                                                                                                                                                                                                                                                                                                                                          method delete

                                                                                                                                                                                                                                                                                                                                          delete: (documentRef: DocumentReference<any>) => WriteBatch;
                                                                                                                                                                                                                                                                                                                                          • Deletes the document referred to by the provided DocumentReference.

                                                                                                                                                                                                                                                                                                                                            Parameter documentRef

                                                                                                                                                                                                                                                                                                                                            A reference to the document to be deleted. This WriteBatch instance. Used for chaining method calls.

                                                                                                                                                                                                                                                                                                                                          method set

                                                                                                                                                                                                                                                                                                                                          set: {
                                                                                                                                                                                                                                                                                                                                          <T>(
                                                                                                                                                                                                                                                                                                                                          documentRef: DocumentReference<T>,
                                                                                                                                                                                                                                                                                                                                          data: Partial<T>,
                                                                                                                                                                                                                                                                                                                                          options: SetOptions
                                                                                                                                                                                                                                                                                                                                          ): WriteBatch;
                                                                                                                                                                                                                                                                                                                                          <T>(documentRef: DocumentReference<T>, data: T): WriteBatch;
                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                          • Writes to the document referred to by the provided DocumentReference. If the document does not exist yet, it will be created. If you pass SetOptions, the provided data can be merged into the existing document.

                                                                                                                                                                                                                                                                                                                                            Parameter documentRef

                                                                                                                                                                                                                                                                                                                                            A reference to the document to be set.

                                                                                                                                                                                                                                                                                                                                            Parameter data

                                                                                                                                                                                                                                                                                                                                            An object of the fields and values for the document.

                                                                                                                                                                                                                                                                                                                                            Parameter options

                                                                                                                                                                                                                                                                                                                                            An object to configure the set behavior. This WriteBatch instance. Used for chaining method calls.

                                                                                                                                                                                                                                                                                                                                          • Writes to the document referred to by the provided DocumentReference. If the document does not exist yet, it will be created. If you pass SetOptions, the provided data can be merged into the existing document.

                                                                                                                                                                                                                                                                                                                                            Parameter documentRef

                                                                                                                                                                                                                                                                                                                                            A reference to the document to be set.

                                                                                                                                                                                                                                                                                                                                            Parameter data

                                                                                                                                                                                                                                                                                                                                            An object of the fields and values for the document. This WriteBatch instance. Used for chaining method calls.

                                                                                                                                                                                                                                                                                                                                          method update

                                                                                                                                                                                                                                                                                                                                          update: {
                                                                                                                                                                                                                                                                                                                                          (documentRef: DocumentReference<any>, data: UpdateData): WriteBatch;
                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                          documentRef: DocumentReference<any>,
                                                                                                                                                                                                                                                                                                                                          field: string | FieldPath,
                                                                                                                                                                                                                                                                                                                                          value: any,
                                                                                                                                                                                                                                                                                                                                          ...moreFieldsAndValues: any[]
                                                                                                                                                                                                                                                                                                                                          ): WriteBatch;
                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                          • Updates fields in the document referred to by the provided DocumentReference. The update will fail if applied to a document that does not exist.

                                                                                                                                                                                                                                                                                                                                            Parameter documentRef

                                                                                                                                                                                                                                                                                                                                            A reference to the document to be updated.

                                                                                                                                                                                                                                                                                                                                            Parameter data

                                                                                                                                                                                                                                                                                                                                            An object containing the fields and values with which to update the document. Fields can contain dots to reference nested fields within the document. This WriteBatch instance. Used for chaining method calls.

                                                                                                                                                                                                                                                                                                                                          • Updates fields in the document referred to by this DocumentReference. The update will fail if applied to a document that does not exist.

                                                                                                                                                                                                                                                                                                                                            Nested fields can be update by providing dot-separated field path strings or by providing FieldPath objects.

                                                                                                                                                                                                                                                                                                                                            Parameter documentRef

                                                                                                                                                                                                                                                                                                                                            A reference to the document to be updated.

                                                                                                                                                                                                                                                                                                                                            Parameter field

                                                                                                                                                                                                                                                                                                                                            The first field to update.

                                                                                                                                                                                                                                                                                                                                            Parameter value

                                                                                                                                                                                                                                                                                                                                            The first value.

                                                                                                                                                                                                                                                                                                                                            Parameter moreFieldsAndValues

                                                                                                                                                                                                                                                                                                                                            Additional key value pairs. A Promise resolved once the data has been successfully written to the backend (Note that it won't resolve while you're offline).

                                                                                                                                                                                                                                                                                                                                          interface DocumentChange

                                                                                                                                                                                                                                                                                                                                          interface DocumentChange<T = DocumentData> {}
                                                                                                                                                                                                                                                                                                                                          • A DocumentChange represents a change to the documents matching a query. It contains the document affected and the type of change that occurred.

                                                                                                                                                                                                                                                                                                                                          property doc

                                                                                                                                                                                                                                                                                                                                          readonly doc: QueryDocumentSnapshot<T>;
                                                                                                                                                                                                                                                                                                                                          • The document affected by this change.

                                                                                                                                                                                                                                                                                                                                          property newIndex

                                                                                                                                                                                                                                                                                                                                          readonly newIndex: number;
                                                                                                                                                                                                                                                                                                                                          • The index of the changed document in the result set immediately after this DocumentChange (i.e. supposing that all prior DocumentChange objects and the current DocumentChange object have been applied). Is -1 for 'removed' events.

                                                                                                                                                                                                                                                                                                                                          property oldIndex

                                                                                                                                                                                                                                                                                                                                          readonly oldIndex: number;
                                                                                                                                                                                                                                                                                                                                          • The index of the changed document in the result set immediately prior to this DocumentChange (i.e. supposing that all prior DocumentChange objects have been applied). Is -1 for 'added' events.

                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                          readonly type: DocumentChangeType;
                                                                                                                                                                                                                                                                                                                                          • The type of change ('added', 'modified', or 'removed').

                                                                                                                                                                                                                                                                                                                                          interface FirestoreDataConverter

                                                                                                                                                                                                                                                                                                                                          interface FirestoreDataConverter<T> {}
                                                                                                                                                                                                                                                                                                                                          • Converter used by withConverter() to transform user objects of type T into Firestore data.

                                                                                                                                                                                                                                                                                                                                            Using the converter allows you to specify generic type arguments when storing and retrieving objects from Firestore.

                                                                                                                                                                                                                                                                                                                                            Example 1

                                                                                                                                                                                                                                                                                                                                            class Post {
                                                                                                                                                                                                                                                                                                                                            constructor(readonly title: string, readonly author: string) {}
                                                                                                                                                                                                                                                                                                                                            toString(): string {
                                                                                                                                                                                                                                                                                                                                            return this.title + ', by ' + this.author;
                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                            const postConverter = {
                                                                                                                                                                                                                                                                                                                                            toFirestore(post: Post): firebase.firestore.DocumentData {
                                                                                                                                                                                                                                                                                                                                            return {title: post.title, author: post.author};
                                                                                                                                                                                                                                                                                                                                            },
                                                                                                                                                                                                                                                                                                                                            fromFirestore(
                                                                                                                                                                                                                                                                                                                                            snapshot: firebase.firestore.QueryDocumentSnapshot,
                                                                                                                                                                                                                                                                                                                                            options: firebase.firestore.SnapshotOptions
                                                                                                                                                                                                                                                                                                                                            ): Post {
                                                                                                                                                                                                                                                                                                                                            const data = snapshot.data(options)!;
                                                                                                                                                                                                                                                                                                                                            return new Post(data.title, data.author);
                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                            const postSnap = await firebase.firestore()
                                                                                                                                                                                                                                                                                                                                            .collection('posts')
                                                                                                                                                                                                                                                                                                                                            .withConverter(postConverter)
                                                                                                                                                                                                                                                                                                                                            .doc().get();
                                                                                                                                                                                                                                                                                                                                            const post = postSnap.data();
                                                                                                                                                                                                                                                                                                                                            if (post !== undefined) {
                                                                                                                                                                                                                                                                                                                                            post.title; // string
                                                                                                                                                                                                                                                                                                                                            post.toString(); // Should be defined
                                                                                                                                                                                                                                                                                                                                            post.someNonExistentProperty; // TS error
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                          method fromFirestore

                                                                                                                                                                                                                                                                                                                                          fromFirestore: (
                                                                                                                                                                                                                                                                                                                                          snapshot: QueryDocumentSnapshot<DocumentData>,
                                                                                                                                                                                                                                                                                                                                          options: SnapshotOptions
                                                                                                                                                                                                                                                                                                                                          ) => T;
                                                                                                                                                                                                                                                                                                                                          • Called by the Firestore SDK to convert Firestore data into an object of type T. You can access your data by calling: snapshot.data(options).

                                                                                                                                                                                                                                                                                                                                            Parameter snapshot

                                                                                                                                                                                                                                                                                                                                            A QueryDocumentSnapshot containing your data and metadata.

                                                                                                                                                                                                                                                                                                                                            Parameter options

                                                                                                                                                                                                                                                                                                                                            The SnapshotOptions from the initial call to data().

                                                                                                                                                                                                                                                                                                                                          method toFirestore

                                                                                                                                                                                                                                                                                                                                          toFirestore: {
                                                                                                                                                                                                                                                                                                                                          (modelObject: T): DocumentData;
                                                                                                                                                                                                                                                                                                                                          (modelObject: Partial<T>, options: SetOptions): DocumentData;
                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                          • Called by the Firestore SDK to convert a custom model object of type T into a plain JavaScript object (suitable for writing directly to the Firestore database). To use set() with merge and mergeFields, toFirestore() must be defined with Partial<T>.

                                                                                                                                                                                                                                                                                                                                          interface FirestoreError

                                                                                                                                                                                                                                                                                                                                          interface FirestoreError {}
                                                                                                                                                                                                                                                                                                                                          • An error returned by a Firestore operation.

                                                                                                                                                                                                                                                                                                                                          property code

                                                                                                                                                                                                                                                                                                                                          code: FirestoreErrorCode;

                                                                                                                                                                                                                                                                                                                                            property message

                                                                                                                                                                                                                                                                                                                                            message: string;

                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                                                                                                                                property stack

                                                                                                                                                                                                                                                                                                                                                stack?: string;

                                                                                                                                                                                                                                                                                                                                                  interface GetOptions

                                                                                                                                                                                                                                                                                                                                                  interface GetOptions {}
                                                                                                                                                                                                                                                                                                                                                  • An options object that configures the behavior of get() calls on DocumentReference and Query. By providing a GetOptions object, these methods can be configured to fetch results only from the server, only from the local cache or attempt to fetch results from the server and fall back to the cache (which is the default).

                                                                                                                                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                                                                                                                                  readonly source?: 'default' | 'server' | 'cache';
                                                                                                                                                                                                                                                                                                                                                  • Describes whether we should get from server or cache.

                                                                                                                                                                                                                                                                                                                                                    Setting to default (or not setting at all), causes Firestore to try to retrieve an up-to-date (server-retrieved) snapshot, but fall back to returning cached data if the server can't be reached.

                                                                                                                                                                                                                                                                                                                                                    Setting to server causes Firestore to avoid the cache, generating an error if the server cannot be reached. Note that the cache will still be updated if the server request succeeds. Also note that latency-compensation still takes effect, so any pending write operations will be visible in the returned data (merged into the server-provided data).

                                                                                                                                                                                                                                                                                                                                                    Setting to cache causes Firestore to immediately return a value from the cache, ignoring the server completely (implying that the returned value may be stale with respect to the value on the server.) If there is no data in the cache to satisfy the get() call, DocumentReference.get() will return an error and QuerySnapshot.get() will return an empty QuerySnapshot with no documents.

                                                                                                                                                                                                                                                                                                                                                  interface LoadBundleTask

                                                                                                                                                                                                                                                                                                                                                  interface LoadBundleTask extends PromiseLike<LoadBundleTaskProgress> {}
                                                                                                                                                                                                                                                                                                                                                  • Represents the task of loading a Firestore bundle. It provides progress of bundle loading, as well as task completion and error events.

                                                                                                                                                                                                                                                                                                                                                    The API is compatible with Promise<LoadBundleTaskProgress>.

                                                                                                                                                                                                                                                                                                                                                  method catch

                                                                                                                                                                                                                                                                                                                                                  catch: <R>(
                                                                                                                                                                                                                                                                                                                                                  onRejected: (a: Error) => R | PromiseLike<R>
                                                                                                                                                                                                                                                                                                                                                  ) => Promise<R | LoadBundleTaskProgress>;
                                                                                                                                                                                                                                                                                                                                                  • Implements the Promise<LoadBundleTaskProgress>.catch interface.

                                                                                                                                                                                                                                                                                                                                                    Parameter onRejected

                                                                                                                                                                                                                                                                                                                                                    Called when an error occurs during bundle loading.

                                                                                                                                                                                                                                                                                                                                                  method onProgress

                                                                                                                                                                                                                                                                                                                                                  onProgress: (
                                                                                                                                                                                                                                                                                                                                                  next?: (progress: LoadBundleTaskProgress) => any,
                                                                                                                                                                                                                                                                                                                                                  error?: (error: Error) => any,
                                                                                                                                                                                                                                                                                                                                                  complete?: () => void
                                                                                                                                                                                                                                                                                                                                                  ) => void;
                                                                                                                                                                                                                                                                                                                                                  • Registers functions to listen to bundle loading progress events.

                                                                                                                                                                                                                                                                                                                                                    Parameter next

                                                                                                                                                                                                                                                                                                                                                    Called when there is a progress update from bundle loading. Typically next calls occur each time a Firestore document is loaded from the bundle.

                                                                                                                                                                                                                                                                                                                                                    Parameter error

                                                                                                                                                                                                                                                                                                                                                    Called when an error occurs during bundle loading. The task aborts after reporting the error, and there should be no more updates after this.

                                                                                                                                                                                                                                                                                                                                                    Parameter complete

                                                                                                                                                                                                                                                                                                                                                    Called when the loading task is complete.

                                                                                                                                                                                                                                                                                                                                                  method then

                                                                                                                                                                                                                                                                                                                                                  then: <T, R>(
                                                                                                                                                                                                                                                                                                                                                  onFulfilled?: (a: LoadBundleTaskProgress) => T | PromiseLike<T>,
                                                                                                                                                                                                                                                                                                                                                  onRejected?: (a: Error) => R | PromiseLike<R>
                                                                                                                                                                                                                                                                                                                                                  ) => Promise<T | R>;
                                                                                                                                                                                                                                                                                                                                                  • Implements the Promise<LoadBundleTaskProgress>.then interface.

                                                                                                                                                                                                                                                                                                                                                    Parameter onFulfilled

                                                                                                                                                                                                                                                                                                                                                    Called on the completion of the loading task with a final LoadBundleTaskProgress update. The update will always have its taskState set to "Success".

                                                                                                                                                                                                                                                                                                                                                    Parameter onRejected

                                                                                                                                                                                                                                                                                                                                                    Called when an error occurs during bundle loading.

                                                                                                                                                                                                                                                                                                                                                  interface LoadBundleTaskProgress

                                                                                                                                                                                                                                                                                                                                                  interface LoadBundleTaskProgress {}
                                                                                                                                                                                                                                                                                                                                                  • Represents a progress update or a final state from loading bundles.

                                                                                                                                                                                                                                                                                                                                                  property bytesLoaded

                                                                                                                                                                                                                                                                                                                                                  bytesLoaded: number;
                                                                                                                                                                                                                                                                                                                                                  • How many bytes have been loaded.

                                                                                                                                                                                                                                                                                                                                                  property documentsLoaded

                                                                                                                                                                                                                                                                                                                                                  documentsLoaded: number;
                                                                                                                                                                                                                                                                                                                                                  • How many documents have been loaded.

                                                                                                                                                                                                                                                                                                                                                  property taskState

                                                                                                                                                                                                                                                                                                                                                  taskState: TaskState;
                                                                                                                                                                                                                                                                                                                                                  • Current task state.

                                                                                                                                                                                                                                                                                                                                                  property totalBytes

                                                                                                                                                                                                                                                                                                                                                  totalBytes: number;
                                                                                                                                                                                                                                                                                                                                                  • How many bytes are in the bundle being loaded.

                                                                                                                                                                                                                                                                                                                                                  property totalDocuments

                                                                                                                                                                                                                                                                                                                                                  totalDocuments: number;
                                                                                                                                                                                                                                                                                                                                                  • How many documents are in the bundle being loaded.

                                                                                                                                                                                                                                                                                                                                                  interface PersistenceSettings

                                                                                                                                                                                                                                                                                                                                                  interface PersistenceSettings {}
                                                                                                                                                                                                                                                                                                                                                  • Settings that can be passed to Firestore.enablePersistence() to configure Firestore persistence.

                                                                                                                                                                                                                                                                                                                                                  property experimentalForceOwningTab

                                                                                                                                                                                                                                                                                                                                                  experimentalForceOwningTab?: boolean;
                                                                                                                                                                                                                                                                                                                                                  • Whether to force enable persistence for the client. This cannot be used with synchronizeTabs:true and is primarily intended for use with Web Workers. Setting this to true will enable persistence, but cause other tabs using persistence to fail.

                                                                                                                                                                                                                                                                                                                                                    This setting may be removed in a future release. If you find yourself using it for a specific use case or run into any issues, please tell us about it in https://github.com/firebase/firebase-js-sdk/issues/983.

                                                                                                                                                                                                                                                                                                                                                  property synchronizeTabs

                                                                                                                                                                                                                                                                                                                                                  synchronizeTabs?: boolean;
                                                                                                                                                                                                                                                                                                                                                  • Whether to synchronize the in-memory state of multiple tabs. Setting this to true in all open tabs enables shared access to local persistence, shared execution of queries and latency-compensated local document updates across all connected instances.

                                                                                                                                                                                                                                                                                                                                                    To enable this mode, synchronizeTabs:true needs to be set globally in all active tabs. If omitted or set to 'false', enablePersistence() will fail in all but the first tab.

                                                                                                                                                                                                                                                                                                                                                  interface SetOptions

                                                                                                                                                                                                                                                                                                                                                  interface SetOptions {}
                                                                                                                                                                                                                                                                                                                                                  • An options object that configures the behavior of set() calls in , and . These calls can be configured to perform granular merges instead of overwriting the target documents in their entirety by providing a SetOptions with merge: true.

                                                                                                                                                                                                                                                                                                                                                  property merge

                                                                                                                                                                                                                                                                                                                                                  readonly merge?: boolean;
                                                                                                                                                                                                                                                                                                                                                  • Changes the behavior of a set() call to only replace the values specified in its data argument. Fields omitted from the set() call remain untouched.

                                                                                                                                                                                                                                                                                                                                                  property mergeFields

                                                                                                                                                                                                                                                                                                                                                  readonly mergeFields?: (string | FieldPath)[];
                                                                                                                                                                                                                                                                                                                                                  • Changes the behavior of set() calls to only replace the specified field paths. Any field path that is not specified is ignored and remains untouched.

                                                                                                                                                                                                                                                                                                                                                  interface Settings

                                                                                                                                                                                                                                                                                                                                                  interface Settings {}
                                                                                                                                                                                                                                                                                                                                                  • Specifies custom configurations for your Cloud Firestore instance. You must set these before invoking any other methods.

                                                                                                                                                                                                                                                                                                                                                  property cacheSizeBytes

                                                                                                                                                                                                                                                                                                                                                  cacheSizeBytes?: number;
                                                                                                                                                                                                                                                                                                                                                  • An approximate cache size threshold for the on-disk data. If the cache grows beyond this size, Firestore will start removing data that hasn't been recently used. The size is not a guarantee that the cache will stay below that size, only that if the cache exceeds the given size, cleanup will be attempted.

                                                                                                                                                                                                                                                                                                                                                    The default value is 40 MB. The threshold must be set to at least 1 MB, and can be set to CACHE_SIZE_UNLIMITED to disable garbage collection.

                                                                                                                                                                                                                                                                                                                                                  property experimentalAutoDetectLongPolling

                                                                                                                                                                                                                                                                                                                                                  experimentalAutoDetectLongPolling?: boolean;
                                                                                                                                                                                                                                                                                                                                                  • Configures the SDK's underlying transport (WebChannel) to automatically detect if long-polling should be used. This is very similar to experimentalForceLongPolling, but only uses long-polling if required.

                                                                                                                                                                                                                                                                                                                                                    This setting will likely be enabled by default in future releases and cannot be combined with experimentalForceLongPolling.

                                                                                                                                                                                                                                                                                                                                                    This setting does not work in a Node.js environment.

                                                                                                                                                                                                                                                                                                                                                  property experimentalForceLongPolling

                                                                                                                                                                                                                                                                                                                                                  experimentalForceLongPolling?: boolean;
                                                                                                                                                                                                                                                                                                                                                  • Forces the SDK’s underlying network transport (WebChannel) to use long-polling. Each response from the backend will be closed immediately after the backend sends data (by default responses are kept open in case the backend has more data to send). This avoids incompatibility issues with certain proxies, antivirus software, etc. that incorrectly buffer traffic indefinitely. Use of this option will cause some performance degradation though.

                                                                                                                                                                                                                                                                                                                                                    This setting cannot be used with experimentalAutoDetectLongPolling and may be removed in a future release. If you find yourself using it to work around a specific network reliability issue, please tell us about it in https://github.com/firebase/firebase-js-sdk/issues/1674.

                                                                                                                                                                                                                                                                                                                                                    This setting does not work in a Node.js environment.

                                                                                                                                                                                                                                                                                                                                                  property host

                                                                                                                                                                                                                                                                                                                                                  host?: string;
                                                                                                                                                                                                                                                                                                                                                  • The hostname to connect to.

                                                                                                                                                                                                                                                                                                                                                  property ignoreUndefinedProperties

                                                                                                                                                                                                                                                                                                                                                  ignoreUndefinedProperties?: boolean;
                                                                                                                                                                                                                                                                                                                                                  • Whether to skip nested properties that are set to undefined during object serialization. If set to true, these properties are skipped and not written to Firestore. If set to false or omitted, the SDK throws an exception when it encounters properties of type undefined.

                                                                                                                                                                                                                                                                                                                                                  property merge

                                                                                                                                                                                                                                                                                                                                                  merge?: boolean;
                                                                                                                                                                                                                                                                                                                                                  • Whether to merge the provided settings with the existing settings. If set to true, the settings are merged with existing settings. If set to false or left unset, the settings replace the existing settings.

                                                                                                                                                                                                                                                                                                                                                  property ssl

                                                                                                                                                                                                                                                                                                                                                  ssl?: boolean;
                                                                                                                                                                                                                                                                                                                                                  • Whether to use SSL when connecting.

                                                                                                                                                                                                                                                                                                                                                  interface SnapshotListenOptions

                                                                                                                                                                                                                                                                                                                                                  interface SnapshotListenOptions {}
                                                                                                                                                                                                                                                                                                                                                  • An options object that can be passed to DocumentReference.onSnapshot(), Query.onSnapshot() and QuerySnapshot.docChanges() to control which types of changes to include in the result set.

                                                                                                                                                                                                                                                                                                                                                  property includeMetadataChanges

                                                                                                                                                                                                                                                                                                                                                  readonly includeMetadataChanges?: boolean;
                                                                                                                                                                                                                                                                                                                                                  • Include a change even if only the metadata of the query or of a document changed. Default is false.

                                                                                                                                                                                                                                                                                                                                                  interface SnapshotMetadata

                                                                                                                                                                                                                                                                                                                                                  interface SnapshotMetadata {}
                                                                                                                                                                                                                                                                                                                                                  • Metadata about a snapshot, describing the state of the snapshot.

                                                                                                                                                                                                                                                                                                                                                  property fromCache

                                                                                                                                                                                                                                                                                                                                                  readonly fromCache: boolean;
                                                                                                                                                                                                                                                                                                                                                  • True if the snapshot was created from cached data rather than guaranteed up-to-date server data. If your listener has opted into metadata updates (via SnapshotListenOptions) you will receive another snapshot with fromCache set to false once the client has received up-to-date data from the backend.

                                                                                                                                                                                                                                                                                                                                                  property hasPendingWrites

                                                                                                                                                                                                                                                                                                                                                  readonly hasPendingWrites: boolean;
                                                                                                                                                                                                                                                                                                                                                  • True if the snapshot contains the result of local writes (e.g. set() or update() calls) that have not yet been committed to the backend. If your listener has opted into metadata updates (via SnapshotListenOptions) you will receive another snapshot with hasPendingWrites equal to false once the writes have been committed to the backend.

                                                                                                                                                                                                                                                                                                                                                  method isEqual

                                                                                                                                                                                                                                                                                                                                                  isEqual: (other: SnapshotMetadata) => boolean;
                                                                                                                                                                                                                                                                                                                                                  • Returns true if this SnapshotMetadata is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                                    Parameter other

                                                                                                                                                                                                                                                                                                                                                    The SnapshotMetadata to compare against. true if this SnapshotMetadata is equal to the provided one.

                                                                                                                                                                                                                                                                                                                                                  interface SnapshotOptions

                                                                                                                                                                                                                                                                                                                                                  interface SnapshotOptions {}
                                                                                                                                                                                                                                                                                                                                                  • Options that configure how data is retrieved from a DocumentSnapshot (e.g. the desired behavior for server timestamps that have not yet been set to their final value).

                                                                                                                                                                                                                                                                                                                                                  property serverTimestamps

                                                                                                                                                                                                                                                                                                                                                  readonly serverTimestamps?: 'estimate' | 'previous' | 'none';
                                                                                                                                                                                                                                                                                                                                                  • If set, controls the return value for server timestamps that have not yet been set to their final value.

                                                                                                                                                                                                                                                                                                                                                    By specifying 'estimate', pending server timestamps return an estimate based on the local clock. This estimate will differ from the final value and cause these values to change once the server result becomes available.

                                                                                                                                                                                                                                                                                                                                                    By specifying 'previous', pending timestamps will be ignored and return their previous value instead.

                                                                                                                                                                                                                                                                                                                                                    If omitted or set to 'none', null will be returned by default until the server value becomes available.

                                                                                                                                                                                                                                                                                                                                                  type DocumentChangeType

                                                                                                                                                                                                                                                                                                                                                  type DocumentChangeType = 'added' | 'removed' | 'modified';
                                                                                                                                                                                                                                                                                                                                                  • The type of a DocumentChange may be 'added', 'removed', or 'modified'.

                                                                                                                                                                                                                                                                                                                                                  type DocumentData

                                                                                                                                                                                                                                                                                                                                                  type DocumentData = { [field: string]: any };
                                                                                                                                                                                                                                                                                                                                                  • Document data (for use with DocumentReference.set()) consists of fields mapped to values.

                                                                                                                                                                                                                                                                                                                                                  type EmulatorMockTokenOptions

                                                                                                                                                                                                                                                                                                                                                  type EmulatorMockTokenOptions = firebase.EmulatorMockTokenOptions;

                                                                                                                                                                                                                                                                                                                                                    type FirestoreErrorCode

                                                                                                                                                                                                                                                                                                                                                    type FirestoreErrorCode =
                                                                                                                                                                                                                                                                                                                                                    | 'cancelled'
                                                                                                                                                                                                                                                                                                                                                    | 'unknown'
                                                                                                                                                                                                                                                                                                                                                    | 'invalid-argument'
                                                                                                                                                                                                                                                                                                                                                    | 'deadline-exceeded'
                                                                                                                                                                                                                                                                                                                                                    | 'not-found'
                                                                                                                                                                                                                                                                                                                                                    | 'already-exists'
                                                                                                                                                                                                                                                                                                                                                    | 'permission-denied'
                                                                                                                                                                                                                                                                                                                                                    | 'resource-exhausted'
                                                                                                                                                                                                                                                                                                                                                    | 'failed-precondition'
                                                                                                                                                                                                                                                                                                                                                    | 'aborted'
                                                                                                                                                                                                                                                                                                                                                    | 'out-of-range'
                                                                                                                                                                                                                                                                                                                                                    | 'unimplemented'
                                                                                                                                                                                                                                                                                                                                                    | 'internal'
                                                                                                                                                                                                                                                                                                                                                    | 'unavailable'
                                                                                                                                                                                                                                                                                                                                                    | 'data-loss'
                                                                                                                                                                                                                                                                                                                                                    | 'unauthenticated';
                                                                                                                                                                                                                                                                                                                                                    • The set of Firestore status codes. The codes are the same at the ones exposed by gRPC here: https://github.com/grpc/grpc/blob/master/doc/statuscodes.md

                                                                                                                                                                                                                                                                                                                                                      Possible values: - 'cancelled': The operation was cancelled (typically by the caller). - 'unknown': Unknown error or an error from a different error domain. - 'invalid-argument': Client specified an invalid argument. Note that this differs from 'failed-precondition'. 'invalid-argument' indicates arguments that are problematic regardless of the state of the system (e.g. an invalid field name). - 'deadline-exceeded': Deadline expired before operation could complete. For operations that change the state of the system, this error may be returned even if the operation has completed successfully. For example, a successful response from a server could have been delayed long enough for the deadline to expire. - 'not-found': Some requested document was not found. - 'already-exists': Some document that we attempted to create already exists. - 'permission-denied': The caller does not have permission to execute the specified operation. - 'resource-exhausted': Some resource has been exhausted, perhaps a per-user quota, or perhaps the entire file system is out of space. - 'failed-precondition': Operation was rejected because the system is not in a state required for the operation's execution. - 'aborted': The operation was aborted, typically due to a concurrency issue like transaction aborts, etc. - 'out-of-range': Operation was attempted past the valid range. - 'unimplemented': Operation is not implemented or not supported/enabled. - 'internal': Internal errors. Means some invariants expected by underlying system has been broken. If you see one of these errors, something is very broken. - 'unavailable': The service is currently unavailable. This is most likely a transient condition and may be corrected by retrying with a backoff. - 'data-loss': Unrecoverable data loss or corruption. - 'unauthenticated': The request does not have valid authentication credentials for the operation.

                                                                                                                                                                                                                                                                                                                                                    type LogLevel

                                                                                                                                                                                                                                                                                                                                                    type LogLevel = 'debug' | 'error' | 'silent';

                                                                                                                                                                                                                                                                                                                                                      type OrderByDirection

                                                                                                                                                                                                                                                                                                                                                      type OrderByDirection = 'desc' | 'asc';
                                                                                                                                                                                                                                                                                                                                                      • The direction of a Query.orderBy() clause is specified as 'desc' or 'asc' (descending or ascending).

                                                                                                                                                                                                                                                                                                                                                      type TaskState

                                                                                                                                                                                                                                                                                                                                                      type TaskState = 'Error' | 'Running' | 'Success';
                                                                                                                                                                                                                                                                                                                                                      • Represents the state of bundle loading tasks.

                                                                                                                                                                                                                                                                                                                                                        Both 'Error' and 'Success' are sinking state: task will abort or complete and there will be no more updates after they are reported.

                                                                                                                                                                                                                                                                                                                                                      type UpdateData

                                                                                                                                                                                                                                                                                                                                                      type UpdateData = { [fieldPath: string]: any };
                                                                                                                                                                                                                                                                                                                                                      • Update data (for use with DocumentReference.update()) consists of field paths (e.g. 'foo' or 'foo.baz') mapped to values. Fields that contain dots reference nested fields within the document.

                                                                                                                                                                                                                                                                                                                                                      type WhereFilterOp

                                                                                                                                                                                                                                                                                                                                                      type WhereFilterOp =
                                                                                                                                                                                                                                                                                                                                                      | '<'
                                                                                                                                                                                                                                                                                                                                                      | '<='
                                                                                                                                                                                                                                                                                                                                                      | '=='
                                                                                                                                                                                                                                                                                                                                                      | '!='
                                                                                                                                                                                                                                                                                                                                                      | '>='
                                                                                                                                                                                                                                                                                                                                                      | '>'
                                                                                                                                                                                                                                                                                                                                                      | 'array-contains'
                                                                                                                                                                                                                                                                                                                                                      | 'in'
                                                                                                                                                                                                                                                                                                                                                      | 'array-contains-any'
                                                                                                                                                                                                                                                                                                                                                      | 'not-in';
                                                                                                                                                                                                                                                                                                                                                      • Filter conditions in a Query.where() clause are specified using the strings '<', '<=', '==', '!=', '>=', '>', 'array-contains', 'in', 'array-contains-any', and 'not-in'.

                                                                                                                                                                                                                                                                                                                                                      namespace firebase.functions

                                                                                                                                                                                                                                                                                                                                                      namespace firebase.functions {}

                                                                                                                                                                                                                                                                                                                                                        class Functions

                                                                                                                                                                                                                                                                                                                                                        class Functions {}
                                                                                                                                                                                                                                                                                                                                                        • The Cloud Functions for Firebase service interface.

                                                                                                                                                                                                                                                                                                                                                          Do not call this constructor directly. Instead, use .

                                                                                                                                                                                                                                                                                                                                                        method httpsCallable

                                                                                                                                                                                                                                                                                                                                                        httpsCallable: (name: string, options?: HttpsCallableOptions) => HttpsCallable;
                                                                                                                                                                                                                                                                                                                                                        • Gets an HttpsCallable instance that refers to the function with the given name.

                                                                                                                                                                                                                                                                                                                                                          Parameter name

                                                                                                                                                                                                                                                                                                                                                          The name of the https callable function.

                                                                                                                                                                                                                                                                                                                                                          Parameter options

                                                                                                                                                                                                                                                                                                                                                          The options for this HttpsCallable instance. The HttpsCallable instance.

                                                                                                                                                                                                                                                                                                                                                        method useEmulator

                                                                                                                                                                                                                                                                                                                                                        useEmulator: (host: string, port: number) => void;
                                                                                                                                                                                                                                                                                                                                                        • Modify this instance to communicate with the Cloud Functions emulator.

                                                                                                                                                                                                                                                                                                                                                          Note: this must be called before this instance has been used to do any operations.

                                                                                                                                                                                                                                                                                                                                                          Parameter host

                                                                                                                                                                                                                                                                                                                                                          The emulator host (ex: localhost)

                                                                                                                                                                                                                                                                                                                                                          Parameter port

                                                                                                                                                                                                                                                                                                                                                          The emulator port (ex: 5001)

                                                                                                                                                                                                                                                                                                                                                        method useFunctionsEmulator

                                                                                                                                                                                                                                                                                                                                                        useFunctionsEmulator: (url: string) => void;
                                                                                                                                                                                                                                                                                                                                                        • Changes this instance to point to a Cloud Functions emulator running locally. See https://firebase.google.com/docs/functions/local-emulator

                                                                                                                                                                                                                                                                                                                                                          Parameter origin

                                                                                                                                                                                                                                                                                                                                                          The origin of the local emulator, such as "http://localhost:5005".

                                                                                                                                                                                                                                                                                                                                                          Deprecated

                                                                                                                                                                                                                                                                                                                                                          Prefer the useEmulator(host, port) method.

                                                                                                                                                                                                                                                                                                                                                        interface HttpsCallable

                                                                                                                                                                                                                                                                                                                                                        interface HttpsCallable {}
                                                                                                                                                                                                                                                                                                                                                        • An HttpsCallable is a reference to a "callable" http trigger in Google Cloud Functions.

                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                        (data?: any): Promise<HttpsCallableResult>;

                                                                                                                                                                                                                                                                                                                                                          interface HttpsCallableOptions

                                                                                                                                                                                                                                                                                                                                                          interface HttpsCallableOptions {}

                                                                                                                                                                                                                                                                                                                                                            property timeout

                                                                                                                                                                                                                                                                                                                                                            timeout?: number;

                                                                                                                                                                                                                                                                                                                                                              interface HttpsCallableResult

                                                                                                                                                                                                                                                                                                                                                              interface HttpsCallableResult {}
                                                                                                                                                                                                                                                                                                                                                              • An HttpsCallableResult wraps a single result from a function call.

                                                                                                                                                                                                                                                                                                                                                              property data

                                                                                                                                                                                                                                                                                                                                                              readonly data: any;

                                                                                                                                                                                                                                                                                                                                                                interface HttpsError

                                                                                                                                                                                                                                                                                                                                                                interface HttpsError extends Error {}

                                                                                                                                                                                                                                                                                                                                                                  property code

                                                                                                                                                                                                                                                                                                                                                                  readonly code: FunctionsErrorCode;
                                                                                                                                                                                                                                                                                                                                                                  • A standard error code that will be returned to the client. This also determines the HTTP status code of the response, as defined in code.proto.

                                                                                                                                                                                                                                                                                                                                                                  property details

                                                                                                                                                                                                                                                                                                                                                                  readonly details?: any;
                                                                                                                                                                                                                                                                                                                                                                  • Extra data to be converted to JSON and included in the error response.

                                                                                                                                                                                                                                                                                                                                                                  type FunctionsErrorCode

                                                                                                                                                                                                                                                                                                                                                                  type FunctionsErrorCode =
                                                                                                                                                                                                                                                                                                                                                                  | 'ok'
                                                                                                                                                                                                                                                                                                                                                                  | 'cancelled'
                                                                                                                                                                                                                                                                                                                                                                  | 'unknown'
                                                                                                                                                                                                                                                                                                                                                                  | 'invalid-argument'
                                                                                                                                                                                                                                                                                                                                                                  | 'deadline-exceeded'
                                                                                                                                                                                                                                                                                                                                                                  | 'not-found'
                                                                                                                                                                                                                                                                                                                                                                  | 'already-exists'
                                                                                                                                                                                                                                                                                                                                                                  | 'permission-denied'
                                                                                                                                                                                                                                                                                                                                                                  | 'resource-exhausted'
                                                                                                                                                                                                                                                                                                                                                                  | 'failed-precondition'
                                                                                                                                                                                                                                                                                                                                                                  | 'aborted'
                                                                                                                                                                                                                                                                                                                                                                  | 'out-of-range'
                                                                                                                                                                                                                                                                                                                                                                  | 'unimplemented'
                                                                                                                                                                                                                                                                                                                                                                  | 'internal'
                                                                                                                                                                                                                                                                                                                                                                  | 'unavailable'
                                                                                                                                                                                                                                                                                                                                                                  | 'data-loss'
                                                                                                                                                                                                                                                                                                                                                                  | 'unauthenticated';
                                                                                                                                                                                                                                                                                                                                                                  • The set of Firebase Functions status codes. The codes are the same at the ones exposed by gRPC here: https://github.com/grpc/grpc/blob/master/doc/statuscodes.md

                                                                                                                                                                                                                                                                                                                                                                    Possible values: - 'cancelled': The operation was cancelled (typically by the caller). - 'unknown': Unknown error or an error from a different error domain. - 'invalid-argument': Client specified an invalid argument. Note that this differs from 'failed-precondition'. 'invalid-argument' indicates arguments that are problematic regardless of the state of the system (e.g. an invalid field name). - 'deadline-exceeded': Deadline expired before operation could complete. For operations that change the state of the system, this error may be returned even if the operation has completed successfully. For example, a successful response from a server could have been delayed long enough for the deadline to expire. - 'not-found': Some requested document was not found. - 'already-exists': Some document that we attempted to create already exists. - 'permission-denied': The caller does not have permission to execute the specified operation. - 'resource-exhausted': Some resource has been exhausted, perhaps a per-user quota, or perhaps the entire file system is out of space. - 'failed-precondition': Operation was rejected because the system is not in a state required for the operation's execution. - 'aborted': The operation was aborted, typically due to a concurrency issue like transaction aborts, etc. - 'out-of-range': Operation was attempted past the valid range. - 'unimplemented': Operation is not implemented or not supported/enabled. - 'internal': Internal errors. Means some invariants expected by underlying system has been broken. If you see one of these errors, something is very broken. - 'unavailable': The service is currently unavailable. This is most likely a transient condition and may be corrected by retrying with a backoff. - 'data-loss': Unrecoverable data loss or corruption. - 'unauthenticated': The request does not have valid authentication credentials for the operation.

                                                                                                                                                                                                                                                                                                                                                                  namespace firebase.installations

                                                                                                                                                                                                                                                                                                                                                                  namespace firebase.installations {}

                                                                                                                                                                                                                                                                                                                                                                    interface Installations

                                                                                                                                                                                                                                                                                                                                                                    interface Installations {}
                                                                                                                                                                                                                                                                                                                                                                    • The Firebase Installations service interface.

                                                                                                                                                                                                                                                                                                                                                                      Do not call this constructor directly. Instead, use .

                                                                                                                                                                                                                                                                                                                                                                    property app

                                                                                                                                                                                                                                                                                                                                                                    app: firebase.app.App;
                                                                                                                                                                                                                                                                                                                                                                    • The associated with the Installations service instance.

                                                                                                                                                                                                                                                                                                                                                                      Example 1

                                                                                                                                                                                                                                                                                                                                                                      var app = analytics.app;

                                                                                                                                                                                                                                                                                                                                                                    method delete

                                                                                                                                                                                                                                                                                                                                                                    delete: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                    • Deletes the Firebase Installation and all associated data.

                                                                                                                                                                                                                                                                                                                                                                    method getId

                                                                                                                                                                                                                                                                                                                                                                    getId: () => Promise<string>;
                                                                                                                                                                                                                                                                                                                                                                    • Creates a Firebase Installation if there isn't one for the app and returns the Installation ID.

                                                                                                                                                                                                                                                                                                                                                                      Firebase Installation ID

                                                                                                                                                                                                                                                                                                                                                                    method getToken

                                                                                                                                                                                                                                                                                                                                                                    getToken: (forceRefresh?: boolean) => Promise<string>;
                                                                                                                                                                                                                                                                                                                                                                    • Returns an Authentication Token for the current Firebase Installation.

                                                                                                                                                                                                                                                                                                                                                                      Firebase Installation Authentication Token

                                                                                                                                                                                                                                                                                                                                                                    method onIdChange

                                                                                                                                                                                                                                                                                                                                                                    onIdChange: (callback: (installationId: string) => void) => () => void;
                                                                                                                                                                                                                                                                                                                                                                    • Sets a new callback that will get called when Installation ID changes. Returns an unsubscribe function that will remove the callback when called.

                                                                                                                                                                                                                                                                                                                                                                    namespace firebase.messaging

                                                                                                                                                                                                                                                                                                                                                                    namespace firebase.messaging {}

                                                                                                                                                                                                                                                                                                                                                                      function isSupported

                                                                                                                                                                                                                                                                                                                                                                      isSupported: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                        interface FcmOptions

                                                                                                                                                                                                                                                                                                                                                                        interface FcmOptions {}
                                                                                                                                                                                                                                                                                                                                                                        • Options for features provided by the FCM SDK for Web. See .

                                                                                                                                                                                                                                                                                                                                                                        property analyticsLabel

                                                                                                                                                                                                                                                                                                                                                                        analyticsLabel?: string;
                                                                                                                                                                                                                                                                                                                                                                        • Label associated with the message's analytics data. See .

                                                                                                                                                                                                                                                                                                                                                                        link?: string;
                                                                                                                                                                                                                                                                                                                                                                        • The link to open when the user clicks on the notification. For all URL values, HTTPS is required. For example, by setting this value to your app's URL, a notification click event will put your app in focus for the user.

                                                                                                                                                                                                                                                                                                                                                                        interface MessagePayload

                                                                                                                                                                                                                                                                                                                                                                        interface MessagePayload {}
                                                                                                                                                                                                                                                                                                                                                                        • Message payload that contains the notification payload that is represented with firebase.messaging.NotificationPayload and the data payload that contains an arbitrary number of key-value pairs sent by developers through the

                                                                                                                                                                                                                                                                                                                                                                        property collapseKey

                                                                                                                                                                                                                                                                                                                                                                        collapseKey: string;
                                                                                                                                                                                                                                                                                                                                                                        • The collapse key of this message. See .

                                                                                                                                                                                                                                                                                                                                                                        property data

                                                                                                                                                                                                                                                                                                                                                                        data?: { [key: string]: string };
                                                                                                                                                                                                                                                                                                                                                                        • Arbitrary key/value pairs.

                                                                                                                                                                                                                                                                                                                                                                        property fcmOptions

                                                                                                                                                                                                                                                                                                                                                                        fcmOptions?: FcmOptions;

                                                                                                                                                                                                                                                                                                                                                                        property from

                                                                                                                                                                                                                                                                                                                                                                        from: string;
                                                                                                                                                                                                                                                                                                                                                                        • The sender of this message.

                                                                                                                                                                                                                                                                                                                                                                        property notification

                                                                                                                                                                                                                                                                                                                                                                        notification?: NotificationPayload;

                                                                                                                                                                                                                                                                                                                                                                        interface Messaging

                                                                                                                                                                                                                                                                                                                                                                        interface Messaging {}
                                                                                                                                                                                                                                                                                                                                                                        • The Firebase Messaging service interface.

                                                                                                                                                                                                                                                                                                                                                                          Do not call this constructor directly. Instead, use .

                                                                                                                                                                                                                                                                                                                                                                          See for a full guide on how to use the Firebase Messaging service.

                                                                                                                                                                                                                                                                                                                                                                        method deleteToken

                                                                                                                                                                                                                                                                                                                                                                        deleteToken: () => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                        • Deletes the registration token associated with this messaging instance and unsubscribes the messaging instance from the push subscription.

                                                                                                                                                                                                                                                                                                                                                                          The promise resolves when the token has been successfully deleted.

                                                                                                                                                                                                                                                                                                                                                                        method getToken

                                                                                                                                                                                                                                                                                                                                                                        getToken: (options?: {
                                                                                                                                                                                                                                                                                                                                                                        vapidKey?: string;
                                                                                                                                                                                                                                                                                                                                                                        serviceWorkerRegistration?: ServiceWorkerRegistration;
                                                                                                                                                                                                                                                                                                                                                                        }) => Promise<string>;
                                                                                                                                                                                                                                                                                                                                                                        • Subscribes the messaging instance to push notifications. Returns an FCM registration token that can be used to send push messages to that messaging instance.

                                                                                                                                                                                                                                                                                                                                                                          If a notification permission isn't already granted, this method asks the user for permission. The returned promise rejects if the user does not allow the app to show notifications.

                                                                                                                                                                                                                                                                                                                                                                          Parameter

                                                                                                                                                                                                                                                                                                                                                                          options.vapidKey The public server key provided to push services. It is used to authenticate the push subscribers to receive push messages only from sending servers that hold the corresponding private key. If it is not provided, a default VAPID key is used. Note that some push services (Chrome Push Service) require a non-default VAPID key. Therefore, it is recommended to generate and import a VAPID key for your project with . See for details on web push services.}

                                                                                                                                                                                                                                                                                                                                                                          Parameter

                                                                                                                                                                                                                                                                                                                                                                          options.serviceWorkerRegistration The service worker registration for receiving push messaging. If the registration is not provided explicitly, you need to have a firebase-messaging-sw.js at your root location. See Access the registration token for more details.

                                                                                                                                                                                                                                                                                                                                                                          The promise resolves with an FCM registration token.

                                                                                                                                                                                                                                                                                                                                                                        method onBackgroundMessage

                                                                                                                                                                                                                                                                                                                                                                        onBackgroundMessage: (
                                                                                                                                                                                                                                                                                                                                                                        nextOrObserver:
                                                                                                                                                                                                                                                                                                                                                                        | firebase.NextFn<MessagePayload>
                                                                                                                                                                                                                                                                                                                                                                        | firebase.Observer<MessagePayload>
                                                                                                                                                                                                                                                                                                                                                                        ) => firebase.Unsubscribe;
                                                                                                                                                                                                                                                                                                                                                                        • Called when a message is received while the app is in the background. An app is considered to be in the background if no active window is displayed.

                                                                                                                                                                                                                                                                                                                                                                          Parameter nextOrObserver

                                                                                                                                                                                                                                                                                                                                                                          This function, or observer object with next defined, is called when a message is received and the app is currently in the background.

                                                                                                                                                                                                                                                                                                                                                                          To stop listening for messages execute this returned function

                                                                                                                                                                                                                                                                                                                                                                        method onMessage

                                                                                                                                                                                                                                                                                                                                                                        onMessage: (
                                                                                                                                                                                                                                                                                                                                                                        nextOrObserver: firebase.NextFn<any> | firebase.Observer<any>
                                                                                                                                                                                                                                                                                                                                                                        ) => firebase.Unsubscribe;
                                                                                                                                                                                                                                                                                                                                                                        • When a push message is received and the user is currently on a page for your origin, the message is passed to the page and an onMessage() event is dispatched with the payload of the push message.

                                                                                                                                                                                                                                                                                                                                                                          Parameter nextOrObserver

                                                                                                                                                                                                                                                                                                                                                                          This function, or observer object with next defined, is called when a message is received and the user is currently viewing your page. To stop listening for messages execute this returned function.

                                                                                                                                                                                                                                                                                                                                                                        interface NotificationPayload

                                                                                                                                                                                                                                                                                                                                                                        interface NotificationPayload {}
                                                                                                                                                                                                                                                                                                                                                                        • Parameters that define how a push notification is displayed to users.

                                                                                                                                                                                                                                                                                                                                                                        property body

                                                                                                                                                                                                                                                                                                                                                                        body?: string;
                                                                                                                                                                                                                                                                                                                                                                        • The body of a notification.

                                                                                                                                                                                                                                                                                                                                                                        property image

                                                                                                                                                                                                                                                                                                                                                                        image?: string;
                                                                                                                                                                                                                                                                                                                                                                        • The URL of the image that is shown with the notification. See for supported image format.

                                                                                                                                                                                                                                                                                                                                                                        property title

                                                                                                                                                                                                                                                                                                                                                                        title?: string;
                                                                                                                                                                                                                                                                                                                                                                        • The title of a notification.

                                                                                                                                                                                                                                                                                                                                                                        namespace firebase.performance

                                                                                                                                                                                                                                                                                                                                                                        namespace firebase.performance {}

                                                                                                                                                                                                                                                                                                                                                                          interface Performance

                                                                                                                                                                                                                                                                                                                                                                          interface Performance {}
                                                                                                                                                                                                                                                                                                                                                                          • The Firebase Performance Monitoring service interface.

                                                                                                                                                                                                                                                                                                                                                                            Do not call this constructor directly. Instead, use .

                                                                                                                                                                                                                                                                                                                                                                          property app

                                                                                                                                                                                                                                                                                                                                                                          app: firebase.app.App;
                                                                                                                                                                                                                                                                                                                                                                          • The associated with the Performance service instance.

                                                                                                                                                                                                                                                                                                                                                                            Example 1

                                                                                                                                                                                                                                                                                                                                                                            var app = analytics.app;

                                                                                                                                                                                                                                                                                                                                                                          property dataCollectionEnabled

                                                                                                                                                                                                                                                                                                                                                                          dataCollectionEnabled: boolean;
                                                                                                                                                                                                                                                                                                                                                                          • Controls the logging of custom traces.

                                                                                                                                                                                                                                                                                                                                                                          property instrumentationEnabled

                                                                                                                                                                                                                                                                                                                                                                          instrumentationEnabled: boolean;
                                                                                                                                                                                                                                                                                                                                                                          • Controls the logging of automatic traces and HTTP/S network monitoring.

                                                                                                                                                                                                                                                                                                                                                                          method trace

                                                                                                                                                                                                                                                                                                                                                                          trace: (traceName: string) => Trace;
                                                                                                                                                                                                                                                                                                                                                                          • Creates an uninitialized instance of and returns it.

                                                                                                                                                                                                                                                                                                                                                                            Parameter traceName

                                                                                                                                                                                                                                                                                                                                                                            The name of the trace instance. The Trace instance.

                                                                                                                                                                                                                                                                                                                                                                          interface Trace

                                                                                                                                                                                                                                                                                                                                                                          interface Trace {}

                                                                                                                                                                                                                                                                                                                                                                            method getAttribute

                                                                                                                                                                                                                                                                                                                                                                            getAttribute: (attr: string) => string | undefined;
                                                                                                                                                                                                                                                                                                                                                                            • Retrieves the value that the custom attribute is set to.

                                                                                                                                                                                                                                                                                                                                                                              Parameter attr

                                                                                                                                                                                                                                                                                                                                                                              Name of the custom attribute.

                                                                                                                                                                                                                                                                                                                                                                            method getAttributes

                                                                                                                                                                                                                                                                                                                                                                            getAttributes: () => { [key: string]: string };
                                                                                                                                                                                                                                                                                                                                                                            • Returns a map of all custom attributes of a instance.

                                                                                                                                                                                                                                                                                                                                                                            method getMetric

                                                                                                                                                                                                                                                                                                                                                                            getMetric: (metricName: string) => number;
                                                                                                                                                                                                                                                                                                                                                                            • Returns the value of the custom metric by that name. If a custom metric with that name does not exist returns zero.

                                                                                                                                                                                                                                                                                                                                                                              Parameter metricName

                                                                                                                                                                                                                                                                                                                                                                              Name of the custom metric.

                                                                                                                                                                                                                                                                                                                                                                            method incrementMetric

                                                                                                                                                                                                                                                                                                                                                                            incrementMetric: (metricName: string, num?: number) => void;
                                                                                                                                                                                                                                                                                                                                                                            • Adds to the value of a custom metric. If a custom metric with the provided name does not exist, it creates one with that name and the value equal to the given number.

                                                                                                                                                                                                                                                                                                                                                                              Parameter metricName

                                                                                                                                                                                                                                                                                                                                                                              The name of the custom metric.

                                                                                                                                                                                                                                                                                                                                                                              Parameter num

                                                                                                                                                                                                                                                                                                                                                                              The number to be added to the value of the custom metric. If not provided, it uses a default value of one.

                                                                                                                                                                                                                                                                                                                                                                            method putAttribute

                                                                                                                                                                                                                                                                                                                                                                            putAttribute: (attr: string, value: string) => void;
                                                                                                                                                                                                                                                                                                                                                                            • Set a custom attribute of a to a certain value.

                                                                                                                                                                                                                                                                                                                                                                              Parameter attr

                                                                                                                                                                                                                                                                                                                                                                              Name of the custom attribute.

                                                                                                                                                                                                                                                                                                                                                                              Parameter value

                                                                                                                                                                                                                                                                                                                                                                              Value of the custom attribute.

                                                                                                                                                                                                                                                                                                                                                                            method putMetric

                                                                                                                                                                                                                                                                                                                                                                            putMetric: (metricName: string, num: number) => void;
                                                                                                                                                                                                                                                                                                                                                                            • Sets the value of the specified custom metric to the given number regardless of whether a metric with that name already exists on the instance or not.

                                                                                                                                                                                                                                                                                                                                                                              Parameter metricName

                                                                                                                                                                                                                                                                                                                                                                              Name of the custom metric.

                                                                                                                                                                                                                                                                                                                                                                              Parameter num

                                                                                                                                                                                                                                                                                                                                                                              Value to of the custom metric.

                                                                                                                                                                                                                                                                                                                                                                            method record

                                                                                                                                                                                                                                                                                                                                                                            record: (
                                                                                                                                                                                                                                                                                                                                                                            startTime: number,
                                                                                                                                                                                                                                                                                                                                                                            duration: number,
                                                                                                                                                                                                                                                                                                                                                                            options?: {
                                                                                                                                                                                                                                                                                                                                                                            metrics?: { [key: string]: number };
                                                                                                                                                                                                                                                                                                                                                                            attributes?: { [key: string]: string };
                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                            ) => void;
                                                                                                                                                                                                                                                                                                                                                                            • Records a from given parameters. This provides a direct way to use without a need to start/stop. This is useful for use cases in which the cannot directly be used (e.g. if the duration was captured before the Performance SDK was loaded).

                                                                                                                                                                                                                                                                                                                                                                              Parameter startTime

                                                                                                                                                                                                                                                                                                                                                                              Trace start time since epoch in millisec.

                                                                                                                                                                                                                                                                                                                                                                              Parameter duration

                                                                                                                                                                                                                                                                                                                                                                              The duration of the trace in millisec.

                                                                                                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                                                                                                              An object which can optionally hold maps of custom metrics and custom attributes.

                                                                                                                                                                                                                                                                                                                                                                            method removeAttribute

                                                                                                                                                                                                                                                                                                                                                                            removeAttribute: (attr: string) => void;
                                                                                                                                                                                                                                                                                                                                                                            • Removes the specified custom attribute from a instance.

                                                                                                                                                                                                                                                                                                                                                                              Parameter attr

                                                                                                                                                                                                                                                                                                                                                                              Name of the custom attribute.

                                                                                                                                                                                                                                                                                                                                                                            method start

                                                                                                                                                                                                                                                                                                                                                                            start: () => void;
                                                                                                                                                                                                                                                                                                                                                                            • Starts the timing for the instance.

                                                                                                                                                                                                                                                                                                                                                                            method stop

                                                                                                                                                                                                                                                                                                                                                                            stop: () => void;
                                                                                                                                                                                                                                                                                                                                                                            • Stops the timing of the instance and logs the data of the instance.

                                                                                                                                                                                                                                                                                                                                                                            namespace firebase.remoteConfig

                                                                                                                                                                                                                                                                                                                                                                            namespace firebase.remoteConfig {}

                                                                                                                                                                                                                                                                                                                                                                              function isSupported

                                                                                                                                                                                                                                                                                                                                                                              isSupported: () => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                              • This method provides two different checks:

                                                                                                                                                                                                                                                                                                                                                                                1. Check if IndexedDB exists in the browser environment. 2. Check if the current browser context allows IndexedDB open() calls.

                                                                                                                                                                                                                                                                                                                                                                                It returns a Promise which resolves to true if a RemoteConfig instance can be initialized in this environment, or false if it cannot.

                                                                                                                                                                                                                                                                                                                                                                              interface RemoteConfig

                                                                                                                                                                                                                                                                                                                                                                              interface RemoteConfig {}
                                                                                                                                                                                                                                                                                                                                                                              • The Firebase Remote Config service interface.

                                                                                                                                                                                                                                                                                                                                                                                Do not call this constructor directly. Instead, use .

                                                                                                                                                                                                                                                                                                                                                                              property app

                                                                                                                                                                                                                                                                                                                                                                              app: firebase.app.App;
                                                                                                                                                                                                                                                                                                                                                                              • The associated with the Performance service instance.

                                                                                                                                                                                                                                                                                                                                                                                Example 1

                                                                                                                                                                                                                                                                                                                                                                                var app = analytics.app;

                                                                                                                                                                                                                                                                                                                                                                              property defaultConfig

                                                                                                                                                                                                                                                                                                                                                                              defaultConfig: { [key: string]: string | number | boolean };
                                                                                                                                                                                                                                                                                                                                                                              • Object containing default values for configs.

                                                                                                                                                                                                                                                                                                                                                                              property fetchTimeMillis

                                                                                                                                                                                                                                                                                                                                                                              fetchTimeMillis: number;
                                                                                                                                                                                                                                                                                                                                                                              • The Unix timestamp in milliseconds of the last successful fetch, or negative one if the RemoteConfig instance either hasn't fetched or initialization is incomplete.

                                                                                                                                                                                                                                                                                                                                                                              property lastFetchStatus

                                                                                                                                                                                                                                                                                                                                                                              lastFetchStatus: FetchStatus;
                                                                                                                                                                                                                                                                                                                                                                              • The status of the last fetch attempt.

                                                                                                                                                                                                                                                                                                                                                                              property settings

                                                                                                                                                                                                                                                                                                                                                                              settings: Settings;
                                                                                                                                                                                                                                                                                                                                                                              • Defines configuration for the Remote Config SDK.

                                                                                                                                                                                                                                                                                                                                                                              method activate

                                                                                                                                                                                                                                                                                                                                                                              activate: () => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                              • Makes the last fetched config available to the getters. Returns a promise which resolves to true if the current call activated the fetched configs. If the fetched configs were already activated, the promise will resolve to false.

                                                                                                                                                                                                                                                                                                                                                                              method ensureInitialized

                                                                                                                                                                                                                                                                                                                                                                              ensureInitialized: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                              • Ensures the last activated config are available to the getters.

                                                                                                                                                                                                                                                                                                                                                                              method fetch

                                                                                                                                                                                                                                                                                                                                                                              fetch: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                              • Fetches and caches configuration from the Remote Config service.

                                                                                                                                                                                                                                                                                                                                                                              method fetchAndActivate

                                                                                                                                                                                                                                                                                                                                                                              fetchAndActivate: () => Promise<boolean>;
                                                                                                                                                                                                                                                                                                                                                                              • Performs fetch and activate operations, as a convenience. Returns a promise which resolves to true if the current call activated the fetched configs. If the fetched configs were already activated, the promise will resolve to false.

                                                                                                                                                                                                                                                                                                                                                                              method getAll

                                                                                                                                                                                                                                                                                                                                                                              getAll: () => { [key: string]: Value };
                                                                                                                                                                                                                                                                                                                                                                              • Gets all config.

                                                                                                                                                                                                                                                                                                                                                                              method getBoolean

                                                                                                                                                                                                                                                                                                                                                                              getBoolean: (key: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                              • Gets the value for the given key as a boolean.

                                                                                                                                                                                                                                                                                                                                                                                Convenience method for calling remoteConfig.getValue(key).asBoolean().

                                                                                                                                                                                                                                                                                                                                                                              method getNumber

                                                                                                                                                                                                                                                                                                                                                                              getNumber: (key: string) => number;
                                                                                                                                                                                                                                                                                                                                                                              • Gets the value for the given key as a number.

                                                                                                                                                                                                                                                                                                                                                                                Convenience method for calling remoteConfig.getValue(key).asNumber().

                                                                                                                                                                                                                                                                                                                                                                              method getString

                                                                                                                                                                                                                                                                                                                                                                              getString: (key: string) => string;
                                                                                                                                                                                                                                                                                                                                                                              • Gets the value for the given key as a String.

                                                                                                                                                                                                                                                                                                                                                                                Convenience method for calling remoteConfig.getValue(key).asString().

                                                                                                                                                                                                                                                                                                                                                                              method getValue

                                                                                                                                                                                                                                                                                                                                                                              getValue: (key: string) => Value;
                                                                                                                                                                                                                                                                                                                                                                              • Gets the Value for the given key.

                                                                                                                                                                                                                                                                                                                                                                              method setLogLevel

                                                                                                                                                                                                                                                                                                                                                                              setLogLevel: (logLevel: LogLevel) => void;
                                                                                                                                                                                                                                                                                                                                                                              • Defines the log level to use.

                                                                                                                                                                                                                                                                                                                                                                              interface Settings

                                                                                                                                                                                                                                                                                                                                                                              interface Settings {}
                                                                                                                                                                                                                                                                                                                                                                              • Defines configuration options for the Remote Config SDK.

                                                                                                                                                                                                                                                                                                                                                                              property fetchTimeoutMillis

                                                                                                                                                                                                                                                                                                                                                                              fetchTimeoutMillis: number;
                                                                                                                                                                                                                                                                                                                                                                              • Defines the maximum amount of milliseconds to wait for a response when fetching configuration from the Remote Config server. Defaults to 60000 (One minute).

                                                                                                                                                                                                                                                                                                                                                                              property minimumFetchIntervalMillis

                                                                                                                                                                                                                                                                                                                                                                              minimumFetchIntervalMillis: number;
                                                                                                                                                                                                                                                                                                                                                                              • Defines the maximum age in milliseconds of an entry in the config cache before it is considered stale. Defaults to 43200000 (Twelve hours).

                                                                                                                                                                                                                                                                                                                                                                              interface Value

                                                                                                                                                                                                                                                                                                                                                                              interface Value {}
                                                                                                                                                                                                                                                                                                                                                                              • Wraps a value with metadata and type-safe getters.

                                                                                                                                                                                                                                                                                                                                                                              method asBoolean

                                                                                                                                                                                                                                                                                                                                                                              asBoolean: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                              • Gets the value as a boolean.

                                                                                                                                                                                                                                                                                                                                                                                The following values (case-insensitive) are interpreted as true: "1", "true", "t", "yes", "y", "on". Other values are interpreted as false.

                                                                                                                                                                                                                                                                                                                                                                              method asNumber

                                                                                                                                                                                                                                                                                                                                                                              asNumber: () => number;
                                                                                                                                                                                                                                                                                                                                                                              • Gets the value as a number. Comparable to calling Number(value) || 0.

                                                                                                                                                                                                                                                                                                                                                                              method asString

                                                                                                                                                                                                                                                                                                                                                                              asString: () => string;
                                                                                                                                                                                                                                                                                                                                                                              • Gets the value as a string.

                                                                                                                                                                                                                                                                                                                                                                              method getSource

                                                                                                                                                                                                                                                                                                                                                                              getSource: () => ValueSource;

                                                                                                                                                                                                                                                                                                                                                                              type FetchStatus

                                                                                                                                                                                                                                                                                                                                                                              type FetchStatus = 'no-fetch-yet' | 'success' | 'failure' | 'throttle';
                                                                                                                                                                                                                                                                                                                                                                              • Summarizes the outcome of the last attempt to fetch config from the Firebase Remote Config server.

                                                                                                                                                                                                                                                                                                                                                                                "no-fetch-yet" indicates the RemoteConfig instance has not yet attempted to fetch config, or that SDK initialization is incomplete. "success" indicates the last attempt succeeded. "failure" indicates the last attempt failed. "throttle" indicates the last attempt was rate-limited.

                                                                                                                                                                                                                                                                                                                                                                              type LogLevel

                                                                                                                                                                                                                                                                                                                                                                              type LogLevel = 'debug' | 'error' | 'silent';
                                                                                                                                                                                                                                                                                                                                                                              • Defines levels of Remote Config logging.

                                                                                                                                                                                                                                                                                                                                                                              type ValueSource

                                                                                                                                                                                                                                                                                                                                                                              type ValueSource = 'static' | 'default' | 'remote';
                                                                                                                                                                                                                                                                                                                                                                              • Indicates the source of a value.

                                                                                                                                                                                                                                                                                                                                                                                "static" indicates the value was defined by a static constant. "default" indicates the value was defined by default config. "remote" indicates the value was defined by fetched config.

                                                                                                                                                                                                                                                                                                                                                                              namespace firebase.storage

                                                                                                                                                                                                                                                                                                                                                                              namespace firebase.storage {}

                                                                                                                                                                                                                                                                                                                                                                                variable StringFormat

                                                                                                                                                                                                                                                                                                                                                                                var StringFormat: {
                                                                                                                                                                                                                                                                                                                                                                                BASE64: string;
                                                                                                                                                                                                                                                                                                                                                                                BASE64URL: string;
                                                                                                                                                                                                                                                                                                                                                                                DATA_URL: string;
                                                                                                                                                                                                                                                                                                                                                                                RAW: string;
                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                  variable TaskEvent

                                                                                                                                                                                                                                                                                                                                                                                  var TaskEvent: { STATE_CHANGED: string };

                                                                                                                                                                                                                                                                                                                                                                                    variable TaskState

                                                                                                                                                                                                                                                                                                                                                                                    var TaskState: {
                                                                                                                                                                                                                                                                                                                                                                                    CANCELED: string;
                                                                                                                                                                                                                                                                                                                                                                                    ERROR: string;
                                                                                                                                                                                                                                                                                                                                                                                    PAUSED: string;
                                                                                                                                                                                                                                                                                                                                                                                    RUNNING: string;
                                                                                                                                                                                                                                                                                                                                                                                    SUCCESS: string;
                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                      interface FirebaseStorageError

                                                                                                                                                                                                                                                                                                                                                                                      interface FirebaseStorageError extends FirebaseError {}
                                                                                                                                                                                                                                                                                                                                                                                      • An error returned by the Firebase Storage SDK.

                                                                                                                                                                                                                                                                                                                                                                                      property customData

                                                                                                                                                                                                                                                                                                                                                                                      customData: {
                                                                                                                                                                                                                                                                                                                                                                                      serverResponse: string | null;
                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                      • Stores custom error data unique to the StorageError.

                                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                                      get status(): number;

                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                        set status(status: number);

                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                          get serverResponse(): null | string;
                                                                                                                                                                                                                                                                                                                                                                                          • Optional response message that was added by the server.

                                                                                                                                                                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                                                                                                                                                                          set serverResponse(serverResponse: string | null);

                                                                                                                                                                                                                                                                                                                                                                                            interface FullMetadata

                                                                                                                                                                                                                                                                                                                                                                                            interface FullMetadata extends firebase.storage.UploadMetadata {}
                                                                                                                                                                                                                                                                                                                                                                                            • The full set of object metadata, including read-only properties.

                                                                                                                                                                                                                                                                                                                                                                                            property bucket

                                                                                                                                                                                                                                                                                                                                                                                            bucket: string;
                                                                                                                                                                                                                                                                                                                                                                                            • The bucket this object is contained in.

                                                                                                                                                                                                                                                                                                                                                                                            property fullPath

                                                                                                                                                                                                                                                                                                                                                                                            fullPath: string;
                                                                                                                                                                                                                                                                                                                                                                                            • The full path of this object.

                                                                                                                                                                                                                                                                                                                                                                                            property generation

                                                                                                                                                                                                                                                                                                                                                                                            generation: string;

                                                                                                                                                                                                                                                                                                                                                                                            property metageneration

                                                                                                                                                                                                                                                                                                                                                                                            metageneration: string;

                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                            name: string;
                                                                                                                                                                                                                                                                                                                                                                                            • The short name of this object, which is the last component of the full path. For example, if fullPath is 'full/path/image.png', name is 'image.png'.

                                                                                                                                                                                                                                                                                                                                                                                            property size

                                                                                                                                                                                                                                                                                                                                                                                            size: number;
                                                                                                                                                                                                                                                                                                                                                                                            • The size of this object, in bytes.

                                                                                                                                                                                                                                                                                                                                                                                            property timeCreated

                                                                                                                                                                                                                                                                                                                                                                                            timeCreated: string;
                                                                                                                                                                                                                                                                                                                                                                                            • A date string representing when this object was created.

                                                                                                                                                                                                                                                                                                                                                                                            property updated

                                                                                                                                                                                                                                                                                                                                                                                            updated: string;
                                                                                                                                                                                                                                                                                                                                                                                            • A date string representing when this object was last updated.

                                                                                                                                                                                                                                                                                                                                                                                            interface ListOptions

                                                                                                                                                                                                                                                                                                                                                                                            interface ListOptions {}
                                                                                                                                                                                                                                                                                                                                                                                            • The options list() accepts.

                                                                                                                                                                                                                                                                                                                                                                                            property maxResults

                                                                                                                                                                                                                                                                                                                                                                                            maxResults?: number | null;
                                                                                                                                                                                                                                                                                                                                                                                            • If set, limits the total number of prefixes and items to return. The default and maximum maxResults is 1000.

                                                                                                                                                                                                                                                                                                                                                                                            property pageToken

                                                                                                                                                                                                                                                                                                                                                                                            pageToken?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                            • The nextPageToken from a previous call to list(). If provided, listing is resumed from the previous position.

                                                                                                                                                                                                                                                                                                                                                                                            interface ListResult

                                                                                                                                                                                                                                                                                                                                                                                            interface ListResult {}
                                                                                                                                                                                                                                                                                                                                                                                            • Result returned by list().

                                                                                                                                                                                                                                                                                                                                                                                            property items

                                                                                                                                                                                                                                                                                                                                                                                            items: Reference[];
                                                                                                                                                                                                                                                                                                                                                                                            • Objects in this directory. You can call getMetadata() and getDownloadUrl() on them.

                                                                                                                                                                                                                                                                                                                                                                                            property nextPageToken

                                                                                                                                                                                                                                                                                                                                                                                            nextPageToken: string | null;
                                                                                                                                                                                                                                                                                                                                                                                            • If set, there might be more results for this list. Use this token to resume the list.

                                                                                                                                                                                                                                                                                                                                                                                            property prefixes

                                                                                                                                                                                                                                                                                                                                                                                            prefixes: Reference[];
                                                                                                                                                                                                                                                                                                                                                                                            • References to prefixes (sub-folders). You can call list() on them to get its contents.

                                                                                                                                                                                                                                                                                                                                                                                              Folders are implicit based on '/' in the object paths. For example, if a bucket has two objects '/a/b/1' and '/a/b/2', list('/a') will return '/a/b' as a prefix.

                                                                                                                                                                                                                                                                                                                                                                                            interface Reference

                                                                                                                                                                                                                                                                                                                                                                                            interface Reference {}
                                                                                                                                                                                                                                                                                                                                                                                            • Represents a reference to a Google Cloud Storage object. Developers can upload, download, and delete objects, as well as get/set object metadata.

                                                                                                                                                                                                                                                                                                                                                                                            property bucket

                                                                                                                                                                                                                                                                                                                                                                                            bucket: string;
                                                                                                                                                                                                                                                                                                                                                                                            • The name of the bucket containing this reference's object.

                                                                                                                                                                                                                                                                                                                                                                                            property fullPath

                                                                                                                                                                                                                                                                                                                                                                                            fullPath: string;
                                                                                                                                                                                                                                                                                                                                                                                            • The full path of this object.

                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                            name: string;
                                                                                                                                                                                                                                                                                                                                                                                            • The short name of this object, which is the last component of the full path. For example, if fullPath is 'full/path/image.png', name is 'image.png'.

                                                                                                                                                                                                                                                                                                                                                                                            property parent

                                                                                                                                                                                                                                                                                                                                                                                            parent: firebase.storage.Reference | null;
                                                                                                                                                                                                                                                                                                                                                                                            • A reference pointing to the parent location of this reference, or null if this reference is the root.

                                                                                                                                                                                                                                                                                                                                                                                            property root

                                                                                                                                                                                                                                                                                                                                                                                            root: firebase.storage.Reference;
                                                                                                                                                                                                                                                                                                                                                                                            • A reference to the root of this reference's bucket.

                                                                                                                                                                                                                                                                                                                                                                                            property storage

                                                                                                                                                                                                                                                                                                                                                                                            storage: firebase.storage.Storage;
                                                                                                                                                                                                                                                                                                                                                                                            • The storage service associated with this reference.

                                                                                                                                                                                                                                                                                                                                                                                            method child

                                                                                                                                                                                                                                                                                                                                                                                            child: (path: string) => Reference;
                                                                                                                                                                                                                                                                                                                                                                                            • Returns a reference to a relative path from this reference.

                                                                                                                                                                                                                                                                                                                                                                                              Parameter path

                                                                                                                                                                                                                                                                                                                                                                                              The relative path from this reference. Leading, trailing, and consecutive slashes are removed. The reference to the given path.

                                                                                                                                                                                                                                                                                                                                                                                            method delete

                                                                                                                                                                                                                                                                                                                                                                                            delete: () => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                            • Deletes the object at this reference's location. A Promise that resolves if the deletion succeeded and rejects if it failed, including if the object didn't exist.

                                                                                                                                                                                                                                                                                                                                                                                            method getDownloadURL

                                                                                                                                                                                                                                                                                                                                                                                            getDownloadURL: () => Promise<string>;
                                                                                                                                                                                                                                                                                                                                                                                            • Fetches a long lived download URL for this object. A Promise that resolves with the download URL or rejects if the fetch failed, including if the object did not exist.

                                                                                                                                                                                                                                                                                                                                                                                            method getMetadata

                                                                                                                                                                                                                                                                                                                                                                                            getMetadata: () => Promise<FullMetadata>;
                                                                                                                                                                                                                                                                                                                                                                                            • Fetches metadata for the object at this location, if one exists. A Promise that resolves with the metadata, or rejects if the fetch failed, including if the object did not exist.

                                                                                                                                                                                                                                                                                                                                                                                            method list

                                                                                                                                                                                                                                                                                                                                                                                            list: (options?: ListOptions) => Promise<ListResult>;
                                                                                                                                                                                                                                                                                                                                                                                            • List items (files) and prefixes (folders) under this storage reference.

                                                                                                                                                                                                                                                                                                                                                                                              List API is only available for Firebase Rules Version 2.

                                                                                                                                                                                                                                                                                                                                                                                              GCS is a key-blob store. Firebase Storage imposes the semantic of '/' delimited folder structure. Refer to GCS's List API if you want to learn more.

                                                                                                                                                                                                                                                                                                                                                                                              To adhere to Firebase Rules's Semantics, Firebase Storage does not support objects whose paths end with "/" or contain two consecutive "/"s. Firebase Storage List API will filter these unsupported objects. list() may fail if there are too many unsupported objects in the bucket.

                                                                                                                                                                                                                                                                                                                                                                                              Parameter options

                                                                                                                                                                                                                                                                                                                                                                                              See ListOptions for details. A Promise that resolves with the items and prefixes. prefixes contains references to sub-folders and items contains references to objects in this folder. nextPageToken can be used to get the rest of the results.

                                                                                                                                                                                                                                                                                                                                                                                            method listAll

                                                                                                                                                                                                                                                                                                                                                                                            listAll: () => Promise<ListResult>;
                                                                                                                                                                                                                                                                                                                                                                                            • List all items (files) and prefixes (folders) under this storage reference.

                                                                                                                                                                                                                                                                                                                                                                                              This is a helper method for calling list() repeatedly until there are no more results. The default pagination size is 1000.

                                                                                                                                                                                                                                                                                                                                                                                              Note: The results may not be consistent if objects are changed while this operation is running.

                                                                                                                                                                                                                                                                                                                                                                                              Warning: listAll may potentially consume too many resources if there are too many results.

                                                                                                                                                                                                                                                                                                                                                                                              A Promise that resolves with all the items and prefixes under the current storage reference. prefixes contains references to sub-directories and items contains references to objects in this folder. nextPageToken is never returned.

                                                                                                                                                                                                                                                                                                                                                                                            method put

                                                                                                                                                                                                                                                                                                                                                                                            put: (
                                                                                                                                                                                                                                                                                                                                                                                            data: Blob | Uint8Array | ArrayBuffer,
                                                                                                                                                                                                                                                                                                                                                                                            metadata?: UploadMetadata
                                                                                                                                                                                                                                                                                                                                                                                            ) => UploadTask;
                                                                                                                                                                                                                                                                                                                                                                                            • Uploads data to this reference's location.

                                                                                                                                                                                                                                                                                                                                                                                              Parameter data

                                                                                                                                                                                                                                                                                                                                                                                              The data to upload.

                                                                                                                                                                                                                                                                                                                                                                                              Parameter metadata

                                                                                                                                                                                                                                                                                                                                                                                              Metadata for the newly uploaded object. An object that can be used to monitor and manage the upload.

                                                                                                                                                                                                                                                                                                                                                                                            method putString

                                                                                                                                                                                                                                                                                                                                                                                            putString: (
                                                                                                                                                                                                                                                                                                                                                                                            data: string,
                                                                                                                                                                                                                                                                                                                                                                                            format?: string,
                                                                                                                                                                                                                                                                                                                                                                                            metadata?: UploadMetadata
                                                                                                                                                                                                                                                                                                                                                                                            ) => UploadTask;
                                                                                                                                                                                                                                                                                                                                                                                            • Uploads string data to this reference's location.

                                                                                                                                                                                                                                                                                                                                                                                              Parameter data

                                                                                                                                                                                                                                                                                                                                                                                              The string to upload.

                                                                                                                                                                                                                                                                                                                                                                                              Parameter format

                                                                                                                                                                                                                                                                                                                                                                                              The format of the string to upload.

                                                                                                                                                                                                                                                                                                                                                                                              Parameter metadata

                                                                                                                                                                                                                                                                                                                                                                                              Metadata for the newly uploaded object.

                                                                                                                                                                                                                                                                                                                                                                                              Throws

                                                                                                                                                                                                                                                                                                                                                                                              If the format is not an allowed format, or if the given string doesn't conform to the specified format.

                                                                                                                                                                                                                                                                                                                                                                                            method toString

                                                                                                                                                                                                                                                                                                                                                                                            toString: () => string;
                                                                                                                                                                                                                                                                                                                                                                                            • Returns a gs:// URL for this object in the form gs://<bucket>/<path>/<to>/<object> The gs:// URL.

                                                                                                                                                                                                                                                                                                                                                                                            method updateMetadata

                                                                                                                                                                                                                                                                                                                                                                                            updateMetadata: (metadata: SettableMetadata) => Promise<FullMetadata>;
                                                                                                                                                                                                                                                                                                                                                                                            • Updates the metadata for the object at this location, if one exists.

                                                                                                                                                                                                                                                                                                                                                                                              Parameter metadata

                                                                                                                                                                                                                                                                                                                                                                                              The new metadata. Setting a property to 'null' removes it on the server, while leaving a property as 'undefined' has no effect. A Promise that resolves with the full updated metadata or rejects if the updated failed, including if the object did not exist.

                                                                                                                                                                                                                                                                                                                                                                                            interface SettableMetadata

                                                                                                                                                                                                                                                                                                                                                                                            interface SettableMetadata {}
                                                                                                                                                                                                                                                                                                                                                                                            • Object metadata that can be set at any time.

                                                                                                                                                                                                                                                                                                                                                                                            property cacheControl

                                                                                                                                                                                                                                                                                                                                                                                            cacheControl?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                            • Served as the 'Cache-Control' header on object download.

                                                                                                                                                                                                                                                                                                                                                                                            property contentDisposition

                                                                                                                                                                                                                                                                                                                                                                                            contentDisposition?: string | null;

                                                                                                                                                                                                                                                                                                                                                                                              property contentEncoding

                                                                                                                                                                                                                                                                                                                                                                                              contentEncoding?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                              • Served as the 'Content-Encoding' header on object download.

                                                                                                                                                                                                                                                                                                                                                                                              property contentLanguage

                                                                                                                                                                                                                                                                                                                                                                                              contentLanguage?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                              • Served as the 'Content-Language' header on object download.

                                                                                                                                                                                                                                                                                                                                                                                              property contentType

                                                                                                                                                                                                                                                                                                                                                                                              contentType?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                              • Served as the 'Content-Type' header on object download.

                                                                                                                                                                                                                                                                                                                                                                                              property customMetadata

                                                                                                                                                                                                                                                                                                                                                                                              customMetadata?: {
                                                                                                                                                                                                                                                                                                                                                                                              [/* warning: coerced from ? */ key: string]: string;
                                                                                                                                                                                                                                                                                                                                                                                              } | null;
                                                                                                                                                                                                                                                                                                                                                                                              • Additional user-defined custom metadata.

                                                                                                                                                                                                                                                                                                                                                                                              interface Storage

                                                                                                                                                                                                                                                                                                                                                                                              interface Storage {}
                                                                                                                                                                                                                                                                                                                                                                                              • The Firebase Storage service interface.

                                                                                                                                                                                                                                                                                                                                                                                                Do not call this constructor directly. Instead, use .

                                                                                                                                                                                                                                                                                                                                                                                                See for a full guide on how to use the Firebase Storage service.

                                                                                                                                                                                                                                                                                                                                                                                              property app

                                                                                                                                                                                                                                                                                                                                                                                              app: firebase.app.App;
                                                                                                                                                                                                                                                                                                                                                                                              • The associated with the Storage service instance.

                                                                                                                                                                                                                                                                                                                                                                                                Example 1

                                                                                                                                                                                                                                                                                                                                                                                                var app = storage.app;

                                                                                                                                                                                                                                                                                                                                                                                              property maxOperationRetryTime

                                                                                                                                                                                                                                                                                                                                                                                              maxOperationRetryTime: number;
                                                                                                                                                                                                                                                                                                                                                                                              • The maximum time to retry operations other than uploads or downloads in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                              property maxUploadRetryTime

                                                                                                                                                                                                                                                                                                                                                                                              maxUploadRetryTime: number;
                                                                                                                                                                                                                                                                                                                                                                                              • The maximum time to retry uploads in milliseconds.

                                                                                                                                                                                                                                                                                                                                                                                              method ref

                                                                                                                                                                                                                                                                                                                                                                                              ref: (path?: string) => Reference;
                                                                                                                                                                                                                                                                                                                                                                                              • Returns a reference for the given path in the default bucket.

                                                                                                                                                                                                                                                                                                                                                                                                Parameter path

                                                                                                                                                                                                                                                                                                                                                                                                A relative path to initialize the reference with, for example path/to/image.jpg. If not passed, the returned reference points to the bucket root. A reference for the given path.

                                                                                                                                                                                                                                                                                                                                                                                              method refFromURL

                                                                                                                                                                                                                                                                                                                                                                                              refFromURL: (url: string) => Reference;
                                                                                                                                                                                                                                                                                                                                                                                              • Returns a reference for the given absolute URL.

                                                                                                                                                                                                                                                                                                                                                                                                Parameter url

                                                                                                                                                                                                                                                                                                                                                                                                A URL in the form: 1) a gs:// URL, for example gs://bucket/files/image.png 2) a download URL taken from object metadata. A reference for the given URL.

                                                                                                                                                                                                                                                                                                                                                                                              method setMaxOperationRetryTime

                                                                                                                                                                                                                                                                                                                                                                                              setMaxOperationRetryTime: (time: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                              method setMaxUploadRetryTime

                                                                                                                                                                                                                                                                                                                                                                                              setMaxUploadRetryTime: (time: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                              method useEmulator

                                                                                                                                                                                                                                                                                                                                                                                              useEmulator: (
                                                                                                                                                                                                                                                                                                                                                                                              host: string,
                                                                                                                                                                                                                                                                                                                                                                                              port: number,
                                                                                                                                                                                                                                                                                                                                                                                              options?: { mockUserToken?: EmulatorMockTokenOptions | string }
                                                                                                                                                                                                                                                                                                                                                                                              ) => void;
                                                                                                                                                                                                                                                                                                                                                                                              • Modify this Storage instance to communicate with the Cloud Storage emulator.

                                                                                                                                                                                                                                                                                                                                                                                                Parameter host

                                                                                                                                                                                                                                                                                                                                                                                                The emulator host (ex: localhost)

                                                                                                                                                                                                                                                                                                                                                                                                Parameter port

                                                                                                                                                                                                                                                                                                                                                                                                The emulator port (ex: 5001)

                                                                                                                                                                                                                                                                                                                                                                                                Parameter

                                                                                                                                                                                                                                                                                                                                                                                                options.mockUserToken the mock auth token to use for unit testing Security Rules

                                                                                                                                                                                                                                                                                                                                                                                              interface StorageObserver

                                                                                                                                                                                                                                                                                                                                                                                              interface StorageObserver<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                property complete

                                                                                                                                                                                                                                                                                                                                                                                                complete?: CompleteFn | null;

                                                                                                                                                                                                                                                                                                                                                                                                  property error

                                                                                                                                                                                                                                                                                                                                                                                                  error?: (error: FirebaseStorageError) => void | null;

                                                                                                                                                                                                                                                                                                                                                                                                    property next

                                                                                                                                                                                                                                                                                                                                                                                                    next?: NextFn<T> | null;

                                                                                                                                                                                                                                                                                                                                                                                                      interface UploadMetadata

                                                                                                                                                                                                                                                                                                                                                                                                      interface UploadMetadata extends firebase.storage.SettableMetadata {}
                                                                                                                                                                                                                                                                                                                                                                                                      • Object metadata that can be set at upload.

                                                                                                                                                                                                                                                                                                                                                                                                      property md5Hash

                                                                                                                                                                                                                                                                                                                                                                                                      md5Hash?: string | null;
                                                                                                                                                                                                                                                                                                                                                                                                      • A Base64-encoded MD5 hash of the object being uploaded.

                                                                                                                                                                                                                                                                                                                                                                                                      interface UploadTask

                                                                                                                                                                                                                                                                                                                                                                                                      interface UploadTask {}
                                                                                                                                                                                                                                                                                                                                                                                                      • Represents the process of uploading an object. Allows you to monitor and manage the upload.

                                                                                                                                                                                                                                                                                                                                                                                                      property snapshot

                                                                                                                                                                                                                                                                                                                                                                                                      snapshot: firebase.storage.UploadTaskSnapshot;
                                                                                                                                                                                                                                                                                                                                                                                                      • A snapshot of the current task state.

                                                                                                                                                                                                                                                                                                                                                                                                      method cancel

                                                                                                                                                                                                                                                                                                                                                                                                      cancel: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                      • Cancels a running task. Has no effect on a complete or failed task. True if the cancel had an effect.

                                                                                                                                                                                                                                                                                                                                                                                                      method catch

                                                                                                                                                                                                                                                                                                                                                                                                      catch: (onRejected: (error: FirebaseStorageError) => any) => Promise<any>;
                                                                                                                                                                                                                                                                                                                                                                                                      • Equivalent to calling then(null, onRejected).

                                                                                                                                                                                                                                                                                                                                                                                                      method on

                                                                                                                                                                                                                                                                                                                                                                                                      on: (
                                                                                                                                                                                                                                                                                                                                                                                                      event: string,
                                                                                                                                                                                                                                                                                                                                                                                                      nextOrObserver?:
                                                                                                                                                                                                                                                                                                                                                                                                      | StorageObserver<UploadTaskSnapshot>
                                                                                                                                                                                                                                                                                                                                                                                                      | ((snapshot: UploadTaskSnapshot) => any),
                                                                                                                                                                                                                                                                                                                                                                                                      error?: (error: FirebaseStorageError) => any,
                                                                                                                                                                                                                                                                                                                                                                                                      complete?: firebase.Unsubscribe | null
                                                                                                                                                                                                                                                                                                                                                                                                      ) => Function;
                                                                                                                                                                                                                                                                                                                                                                                                      • Listens for events on this task.

                                                                                                                                                                                                                                                                                                                                                                                                        Events have three callback functions (referred to as next, error, and complete).

                                                                                                                                                                                                                                                                                                                                                                                                        If only the event is passed, a function that can be used to register the callbacks is returned. Otherwise, the callbacks are passed after the event.

                                                                                                                                                                                                                                                                                                                                                                                                        Callbacks can be passed either as three separate arguments or as the next, error, and complete properties of an object. Any of the three callbacks is optional, as long as at least one is specified. In addition, when you add your callbacks, you get a function back. You can call this function to unregister the associated callbacks.

                                                                                                                                                                                                                                                                                                                                                                                                        Parameter event

                                                                                                                                                                                                                                                                                                                                                                                                        The event to listen for.

                                                                                                                                                                                                                                                                                                                                                                                                        Parameter nextOrObserver

                                                                                                                                                                                                                                                                                                                                                                                                        The next function, which gets called for each item in the event stream, or an observer object with some or all of these three properties (next, error, complete).

                                                                                                                                                                                                                                                                                                                                                                                                        Parameter error

                                                                                                                                                                                                                                                                                                                                                                                                        A function that gets called with a FirebaseStorageError if the event stream ends due to an error.

                                                                                                                                                                                                                                                                                                                                                                                                        Parameter complete

                                                                                                                                                                                                                                                                                                                                                                                                        A function that gets called if the event stream ends normally. If only the event argument is passed, returns a function you can use to add callbacks (see the examples above). If more than just the event argument is passed, returns a function you can call to unregister the callbacks.

                                                                                                                                                                                                                                                                                                                                                                                                        Example 1

                                                                                                                                                                                                                                                                                                                                                                                                        **Pass callbacks separately or in an object.**

                                                                                                                                                                                                                                                                                                                                                                                                        var next = function(snapshot) {};
                                                                                                                                                                                                                                                                                                                                                                                                        var error = function(error) {};
                                                                                                                                                                                                                                                                                                                                                                                                        var complete = function() {};
                                                                                                                                                                                                                                                                                                                                                                                                        // The first example.
                                                                                                                                                                                                                                                                                                                                                                                                        uploadTask.on(
                                                                                                                                                                                                                                                                                                                                                                                                        firebase.storage.TaskEvent.STATE_CHANGED,
                                                                                                                                                                                                                                                                                                                                                                                                        next,
                                                                                                                                                                                                                                                                                                                                                                                                        error,
                                                                                                                                                                                                                                                                                                                                                                                                        complete);
                                                                                                                                                                                                                                                                                                                                                                                                        // This is equivalent to the first example.
                                                                                                                                                                                                                                                                                                                                                                                                        uploadTask.on(firebase.storage.TaskEvent.STATE_CHANGED, {
                                                                                                                                                                                                                                                                                                                                                                                                        'next': next,
                                                                                                                                                                                                                                                                                                                                                                                                        'error': error,
                                                                                                                                                                                                                                                                                                                                                                                                        'complete': complete
                                                                                                                                                                                                                                                                                                                                                                                                        });
                                                                                                                                                                                                                                                                                                                                                                                                        // This is equivalent to the first example.
                                                                                                                                                                                                                                                                                                                                                                                                        var subscribe = uploadTask.on(firebase.storage.TaskEvent.STATE_CHANGED);
                                                                                                                                                                                                                                                                                                                                                                                                        subscribe(next, error, complete);
                                                                                                                                                                                                                                                                                                                                                                                                        // This is equivalent to the first example.
                                                                                                                                                                                                                                                                                                                                                                                                        var subscribe = uploadTask.on(firebase.storage.TaskEvent.STATE_CHANGED);
                                                                                                                                                                                                                                                                                                                                                                                                        subscribe({
                                                                                                                                                                                                                                                                                                                                                                                                        'next': next,
                                                                                                                                                                                                                                                                                                                                                                                                        'error': error,
                                                                                                                                                                                                                                                                                                                                                                                                        'complete': complete
                                                                                                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                                                                                                        Example 2

                                                                                                                                                                                                                                                                                                                                                                                                        **Any callback is optional.**

                                                                                                                                                                                                                                                                                                                                                                                                        // Just listening for completion, this is legal.
                                                                                                                                                                                                                                                                                                                                                                                                        uploadTask.on(
                                                                                                                                                                                                                                                                                                                                                                                                        firebase.storage.TaskEvent.STATE_CHANGED,
                                                                                                                                                                                                                                                                                                                                                                                                        null,
                                                                                                                                                                                                                                                                                                                                                                                                        null,
                                                                                                                                                                                                                                                                                                                                                                                                        function() {
                                                                                                                                                                                                                                                                                                                                                                                                        console.log('upload complete!');
                                                                                                                                                                                                                                                                                                                                                                                                        });
                                                                                                                                                                                                                                                                                                                                                                                                        // Just listening for progress/state changes, this is legal.
                                                                                                                                                                                                                                                                                                                                                                                                        uploadTask.on(firebase.storage.TaskEvent.STATE_CHANGED, function(snapshot) {
                                                                                                                                                                                                                                                                                                                                                                                                        var percent = snapshot.bytesTransferred / snapshot.totalBytes * 100;
                                                                                                                                                                                                                                                                                                                                                                                                        console.log(percent + "% done");
                                                                                                                                                                                                                                                                                                                                                                                                        });
                                                                                                                                                                                                                                                                                                                                                                                                        // This is also legal.
                                                                                                                                                                                                                                                                                                                                                                                                        uploadTask.on(firebase.storage.TaskEvent.STATE_CHANGED, {
                                                                                                                                                                                                                                                                                                                                                                                                        'complete': function() {
                                                                                                                                                                                                                                                                                                                                                                                                        console.log('upload complete!');
                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                                                                                                        Example 3

                                                                                                                                                                                                                                                                                                                                                                                                        **Use the returned function to remove callbacks.**

                                                                                                                                                                                                                                                                                                                                                                                                        var unsubscribe = uploadTask.on(
                                                                                                                                                                                                                                                                                                                                                                                                        firebase.storage.TaskEvent.STATE_CHANGED,
                                                                                                                                                                                                                                                                                                                                                                                                        function(snapshot) {
                                                                                                                                                                                                                                                                                                                                                                                                        var percent = snapshot.bytesTransferred / snapshot.totalBytes * 100;
                                                                                                                                                                                                                                                                                                                                                                                                        console.log(percent + "% done");
                                                                                                                                                                                                                                                                                                                                                                                                        // Stop after receiving one update.
                                                                                                                                                                                                                                                                                                                                                                                                        unsubscribe();
                                                                                                                                                                                                                                                                                                                                                                                                        });
                                                                                                                                                                                                                                                                                                                                                                                                        // This code is equivalent to the above.
                                                                                                                                                                                                                                                                                                                                                                                                        var handle = uploadTask.on(firebase.storage.TaskEvent.STATE_CHANGED);
                                                                                                                                                                                                                                                                                                                                                                                                        unsubscribe = handle(function(snapshot) {
                                                                                                                                                                                                                                                                                                                                                                                                        var percent = snapshot.bytesTransferred / snapshot.totalBytes * 100;
                                                                                                                                                                                                                                                                                                                                                                                                        console.log(percent + "% done");
                                                                                                                                                                                                                                                                                                                                                                                                        // Stop after receiving one update.
                                                                                                                                                                                                                                                                                                                                                                                                        unsubscribe();
                                                                                                                                                                                                                                                                                                                                                                                                        });

                                                                                                                                                                                                                                                                                                                                                                                                      method pause

                                                                                                                                                                                                                                                                                                                                                                                                      pause: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                      • Pauses a running task. Has no effect on a paused or failed task. True if the pause had an effect.

                                                                                                                                                                                                                                                                                                                                                                                                      method resume

                                                                                                                                                                                                                                                                                                                                                                                                      resume: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                      • Resumes a paused task. Has no effect on a running or failed task. True if the resume had an effect.

                                                                                                                                                                                                                                                                                                                                                                                                      method then

                                                                                                                                                                                                                                                                                                                                                                                                      then: (
                                                                                                                                                                                                                                                                                                                                                                                                      onFulfilled?: (snapshot: UploadTaskSnapshot) => any,
                                                                                                                                                                                                                                                                                                                                                                                                      onRejected?: (error: FirebaseStorageError) => any
                                                                                                                                                                                                                                                                                                                                                                                                      ) => Promise<any>;
                                                                                                                                                                                                                                                                                                                                                                                                      • This object behaves like a Promise, and resolves with its snapshot data when the upload completes.

                                                                                                                                                                                                                                                                                                                                                                                                        Parameter onFulfilled

                                                                                                                                                                                                                                                                                                                                                                                                        The fulfillment callback. Promise chaining works as normal.

                                                                                                                                                                                                                                                                                                                                                                                                        Parameter onRejected

                                                                                                                                                                                                                                                                                                                                                                                                        The rejection callback.

                                                                                                                                                                                                                                                                                                                                                                                                      interface UploadTaskSnapshot

                                                                                                                                                                                                                                                                                                                                                                                                      interface UploadTaskSnapshot {}
                                                                                                                                                                                                                                                                                                                                                                                                      • Holds data about the current state of the upload task.

                                                                                                                                                                                                                                                                                                                                                                                                      property bytesTransferred

                                                                                                                                                                                                                                                                                                                                                                                                      bytesTransferred: number;
                                                                                                                                                                                                                                                                                                                                                                                                      • The number of bytes that have been successfully uploaded so far.

                                                                                                                                                                                                                                                                                                                                                                                                      property metadata

                                                                                                                                                                                                                                                                                                                                                                                                      metadata: firebase.storage.FullMetadata;
                                                                                                                                                                                                                                                                                                                                                                                                      • Before the upload completes, contains the metadata sent to the server. After the upload completes, contains the metadata sent back from the server.

                                                                                                                                                                                                                                                                                                                                                                                                      property ref

                                                                                                                                                                                                                                                                                                                                                                                                      ref: firebase.storage.Reference;
                                                                                                                                                                                                                                                                                                                                                                                                      • The reference that spawned this snapshot's upload task.

                                                                                                                                                                                                                                                                                                                                                                                                      property state

                                                                                                                                                                                                                                                                                                                                                                                                      state: firebase.storage.TaskState;
                                                                                                                                                                                                                                                                                                                                                                                                      • The current state of the task.

                                                                                                                                                                                                                                                                                                                                                                                                      property task

                                                                                                                                                                                                                                                                                                                                                                                                      task: firebase.storage.UploadTask;
                                                                                                                                                                                                                                                                                                                                                                                                      • The task of which this is a snapshot.

                                                                                                                                                                                                                                                                                                                                                                                                      property totalBytes

                                                                                                                                                                                                                                                                                                                                                                                                      totalBytes: number;
                                                                                                                                                                                                                                                                                                                                                                                                      • The total number of bytes to be uploaded.

                                                                                                                                                                                                                                                                                                                                                                                                      enum StorageErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                      enum StorageErrorCode {
                                                                                                                                                                                                                                                                                                                                                                                                      UNKNOWN = 'unknown',
                                                                                                                                                                                                                                                                                                                                                                                                      OBJECT_NOT_FOUND = 'object-not-found',
                                                                                                                                                                                                                                                                                                                                                                                                      BUCKET_NOT_FOUND = 'bucket-not-found',
                                                                                                                                                                                                                                                                                                                                                                                                      PROJECT_NOT_FOUND = 'project-not-found',
                                                                                                                                                                                                                                                                                                                                                                                                      QUOTA_EXCEEDED = 'quota-exceeded',
                                                                                                                                                                                                                                                                                                                                                                                                      UNAUTHENTICATED = 'unauthenticated',
                                                                                                                                                                                                                                                                                                                                                                                                      UNAUTHORIZED = 'unauthorized',
                                                                                                                                                                                                                                                                                                                                                                                                      UNAUTHORIZED_APP = 'unauthorized-app',
                                                                                                                                                                                                                                                                                                                                                                                                      RETRY_LIMIT_EXCEEDED = 'retry-limit-exceeded',
                                                                                                                                                                                                                                                                                                                                                                                                      INVALID_CHECKSUM = 'invalid-checksum',
                                                                                                                                                                                                                                                                                                                                                                                                      CANCELED = 'canceled',
                                                                                                                                                                                                                                                                                                                                                                                                      INVALID_EVENT_NAME = 'invalid-event-name',
                                                                                                                                                                                                                                                                                                                                                                                                      INVALID_URL = 'invalid-url',
                                                                                                                                                                                                                                                                                                                                                                                                      INVALID_DEFAULT_BUCKET = 'invalid-default-bucket',
                                                                                                                                                                                                                                                                                                                                                                                                      NO_DEFAULT_BUCKET = 'no-default-bucket',
                                                                                                                                                                                                                                                                                                                                                                                                      CANNOT_SLICE_BLOB = 'cannot-slice-blob',
                                                                                                                                                                                                                                                                                                                                                                                                      SERVER_FILE_WRONG_SIZE = 'server-file-wrong-size',
                                                                                                                                                                                                                                                                                                                                                                                                      NO_DOWNLOAD_URL = 'no-download-url',
                                                                                                                                                                                                                                                                                                                                                                                                      INVALID_ARGUMENT = 'invalid-argument',
                                                                                                                                                                                                                                                                                                                                                                                                      INVALID_ARGUMENT_COUNT = 'invalid-argument-count',
                                                                                                                                                                                                                                                                                                                                                                                                      APP_DELETED = 'app-deleted',
                                                                                                                                                                                                                                                                                                                                                                                                      INVALID_ROOT_OPERATION = 'invalid-root-operation',
                                                                                                                                                                                                                                                                                                                                                                                                      INVALID_FORMAT = 'invalid-format',
                                                                                                                                                                                                                                                                                                                                                                                                      INTERNAL_ERROR = 'internal-error',
                                                                                                                                                                                                                                                                                                                                                                                                      UNSUPPORTED_ENVIRONMENT = 'unsupported-environment',
                                                                                                                                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                                                                                                                                      • Error codes that can be attached to StorageError objects.

                                                                                                                                                                                                                                                                                                                                                                                                      member APP_DELETED

                                                                                                                                                                                                                                                                                                                                                                                                      APP_DELETED = 'app-deleted'

                                                                                                                                                                                                                                                                                                                                                                                                        member BUCKET_NOT_FOUND

                                                                                                                                                                                                                                                                                                                                                                                                        BUCKET_NOT_FOUND = 'bucket-not-found'

                                                                                                                                                                                                                                                                                                                                                                                                          member CANCELED

                                                                                                                                                                                                                                                                                                                                                                                                          CANCELED = 'canceled'

                                                                                                                                                                                                                                                                                                                                                                                                            member CANNOT_SLICE_BLOB

                                                                                                                                                                                                                                                                                                                                                                                                            CANNOT_SLICE_BLOB = 'cannot-slice-blob'

                                                                                                                                                                                                                                                                                                                                                                                                              member INTERNAL_ERROR

                                                                                                                                                                                                                                                                                                                                                                                                              INTERNAL_ERROR = 'internal-error'

                                                                                                                                                                                                                                                                                                                                                                                                                member INVALID_ARGUMENT

                                                                                                                                                                                                                                                                                                                                                                                                                INVALID_ARGUMENT = 'invalid-argument'

                                                                                                                                                                                                                                                                                                                                                                                                                  member INVALID_ARGUMENT_COUNT

                                                                                                                                                                                                                                                                                                                                                                                                                  INVALID_ARGUMENT_COUNT = 'invalid-argument-count'

                                                                                                                                                                                                                                                                                                                                                                                                                    member INVALID_CHECKSUM

                                                                                                                                                                                                                                                                                                                                                                                                                    INVALID_CHECKSUM = 'invalid-checksum'

                                                                                                                                                                                                                                                                                                                                                                                                                      member INVALID_DEFAULT_BUCKET

                                                                                                                                                                                                                                                                                                                                                                                                                      INVALID_DEFAULT_BUCKET = 'invalid-default-bucket'

                                                                                                                                                                                                                                                                                                                                                                                                                        member INVALID_EVENT_NAME

                                                                                                                                                                                                                                                                                                                                                                                                                        INVALID_EVENT_NAME = 'invalid-event-name'

                                                                                                                                                                                                                                                                                                                                                                                                                          member INVALID_FORMAT

                                                                                                                                                                                                                                                                                                                                                                                                                          INVALID_FORMAT = 'invalid-format'

                                                                                                                                                                                                                                                                                                                                                                                                                            member INVALID_ROOT_OPERATION

                                                                                                                                                                                                                                                                                                                                                                                                                            INVALID_ROOT_OPERATION = 'invalid-root-operation'

                                                                                                                                                                                                                                                                                                                                                                                                                              member INVALID_URL

                                                                                                                                                                                                                                                                                                                                                                                                                              INVALID_URL = 'invalid-url'

                                                                                                                                                                                                                                                                                                                                                                                                                                member NO_DEFAULT_BUCKET

                                                                                                                                                                                                                                                                                                                                                                                                                                NO_DEFAULT_BUCKET = 'no-default-bucket'

                                                                                                                                                                                                                                                                                                                                                                                                                                  member NO_DOWNLOAD_URL

                                                                                                                                                                                                                                                                                                                                                                                                                                  NO_DOWNLOAD_URL = 'no-download-url'

                                                                                                                                                                                                                                                                                                                                                                                                                                    member OBJECT_NOT_FOUND

                                                                                                                                                                                                                                                                                                                                                                                                                                    OBJECT_NOT_FOUND = 'object-not-found'

                                                                                                                                                                                                                                                                                                                                                                                                                                      member PROJECT_NOT_FOUND

                                                                                                                                                                                                                                                                                                                                                                                                                                      PROJECT_NOT_FOUND = 'project-not-found'

                                                                                                                                                                                                                                                                                                                                                                                                                                        member QUOTA_EXCEEDED

                                                                                                                                                                                                                                                                                                                                                                                                                                        QUOTA_EXCEEDED = 'quota-exceeded'

                                                                                                                                                                                                                                                                                                                                                                                                                                          member RETRY_LIMIT_EXCEEDED

                                                                                                                                                                                                                                                                                                                                                                                                                                          RETRY_LIMIT_EXCEEDED = 'retry-limit-exceeded'

                                                                                                                                                                                                                                                                                                                                                                                                                                            member SERVER_FILE_WRONG_SIZE

                                                                                                                                                                                                                                                                                                                                                                                                                                            SERVER_FILE_WRONG_SIZE = 'server-file-wrong-size'

                                                                                                                                                                                                                                                                                                                                                                                                                                              member UNAUTHENTICATED

                                                                                                                                                                                                                                                                                                                                                                                                                                              UNAUTHENTICATED = 'unauthenticated'

                                                                                                                                                                                                                                                                                                                                                                                                                                                member UNAUTHORIZED

                                                                                                                                                                                                                                                                                                                                                                                                                                                UNAUTHORIZED = 'unauthorized'

                                                                                                                                                                                                                                                                                                                                                                                                                                                  member UNAUTHORIZED_APP

                                                                                                                                                                                                                                                                                                                                                                                                                                                  UNAUTHORIZED_APP = 'unauthorized-app'

                                                                                                                                                                                                                                                                                                                                                                                                                                                    member UNKNOWN

                                                                                                                                                                                                                                                                                                                                                                                                                                                    UNKNOWN = 'unknown'

                                                                                                                                                                                                                                                                                                                                                                                                                                                      member UNSUPPORTED_ENVIRONMENT

                                                                                                                                                                                                                                                                                                                                                                                                                                                      UNSUPPORTED_ENVIRONMENT = 'unsupported-environment'

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type StringFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type StringFormat = string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • {string} An enumeration of the possible string formats for upload.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TaskEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TaskEvent = string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TaskState

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TaskState = string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Represents the current state of a running upload. {string}

                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace firebase.User

                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace firebase.User {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MultiFactorUser

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface MultiFactorUser {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • This is the interface that defines the multi-factor related properties and operations pertaining to a firebase.User.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property enrolledFactors

                                                                                                                                                                                                                                                                                                                                                                                                                                                          enrolledFactors: firebase.auth.MultiFactorInfo[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns a list of the user's enrolled second factors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method enroll

                                                                                                                                                                                                                                                                                                                                                                                                                                                          enroll: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertion: firebase.auth.MultiFactorAssertion,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          displayName?: string | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Enrolls a second factor as identified by the firebase.auth.MultiFactorAssertion for the current user. On resolution, the user tokens are updated to reflect the change in the JWT payload. Accepts an additional display name parameter used to identify the second factor to the end user. Recent re-authentication is required for this operation to succeed. On successful enrollment, existing Firebase sessions (refresh tokens) are revoked. When a new factor is enrolled, an email notification is sent to the user’s email.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Error Codes auth/invalid-verification-code Thrown if the verification code is not valid. auth/missing-verification-code Thrown if the verification code is missing. auth/invalid-verification-id Thrown if the credential is a firebase.auth.PhoneAuthProvider.credential and the verification ID of the credential is not valid. auth/missing-verification-id Thrown if the verification ID is missing. auth/code-expired Thrown if the verification code has expired. auth/maximum-second-factor-count-exceeded Thrown if The maximum allowed number of second factors on a user has been exceeded. auth/second-factor-already-in-use Thrown if the second factor is already enrolled on this account. auth/unsupported-first-factor Thrown if the first factor being used to sign in is not supported. auth/unverified-email Thrown if the email of the account is not verified. auth/requires-recent-login Thrown if the user's last sign-in time does not meet the security threshold. Use firebase.User.reauthenticateWithCredential to resolve.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter assertion

                                                                                                                                                                                                                                                                                                                                                                                                                                                            The multi-factor assertion to enroll with.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter displayName

                                                                                                                                                                                                                                                                                                                                                                                                                                                            The display name of the second factor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                            firebase.auth().currentUser.multiFactor.getSession()
                                                                                                                                                                                                                                                                                                                                                                                                                                                            .then(function(multiFactorSession) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Send verification code
                                                                                                                                                                                                                                                                                                                                                                                                                                                            var phoneAuthProvider = new firebase.auth.PhoneAuthProvider();
                                                                                                                                                                                                                                                                                                                                                                                                                                                            var phoneInfoOptions = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            phoneNumber: phoneNumber,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            session: multiFactorSession
                                                                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                                                                            return phoneAuthProvider.verifyPhoneNumber(
                                                                                                                                                                                                                                                                                                                                                                                                                                                            phoneInfoOptions, appVerifier);
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }).then(function(verificationId) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Store verificationID and show UI to let user enter verification code.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            });
                                                                                                                                                                                                                                                                                                                                                                                                                                                            var phoneAuthCredential =
                                                                                                                                                                                                                                                                                                                                                                                                                                                            firebase.auth.PhoneAuthProvider.credential(verificationId, verificationCode);
                                                                                                                                                                                                                                                                                                                                                                                                                                                            var multiFactorAssertion =
                                                                                                                                                                                                                                                                                                                                                                                                                                                            firebase.auth.PhoneMultiFactorGenerator.assertion(phoneAuthCredential);
                                                                                                                                                                                                                                                                                                                                                                                                                                                            firebase.auth().currentUser.multiFactor.enroll(multiFactorAssertion)
                                                                                                                                                                                                                                                                                                                                                                                                                                                            .then(function() {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Second factor enrolled.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            });

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getSession

                                                                                                                                                                                                                                                                                                                                                                                                                                                          getSession: () => Promise<firebase.auth.MultiFactorSession>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Returns the session identifier for a second factor enrollment operation. This is used to identify the current user trying to enroll a second factor. The promise that resolves with the firebase.auth.MultiFactorSession.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Error Codes auth/user-token-expired Thrown if the token of the user is expired.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method unenroll

                                                                                                                                                                                                                                                                                                                                                                                                                                                          unenroll: (option: firebase.auth.MultiFactorInfo | string) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Unenrolls the specified second factor. To specify the factor to remove, pass a firebase.auth.MultiFactorInfo object (retrieved from enrolledFactors()) or the factor's UID string. Sessions are not revoked when the account is downgraded. An email notification is likely to be sent to the user notifying them of the change. Recent re-authentication is required for this operation to succeed. When an existing factor is unenrolled, an email notification is sent to the user’s email.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Error Codes auth/multi-factor-info-not-found Thrown if the user does not have a second factor matching the identifier provided. auth/requires-recent-login Thrown if the user's last sign-in time does not meet the security threshold. Use firebase.User.reauthenticateWithCredential to resolve.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter option

                                                                                                                                                                                                                                                                                                                                                                                                                                                            The multi-factor option to unenroll.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                            var options = firebase.auth().currentUser.multiFactor.enrolledFactors;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Present user the option to unenroll.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            return firebase.auth().currentUser.multiFactor.unenroll(options[i])
                                                                                                                                                                                                                                                                                                                                                                                                                                                            .then(function() {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            // User successfully unenrolled selected factor.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }).catch(function(error) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            // Handler error.
                                                                                                                                                                                                                                                                                                                                                                                                                                                            });

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Dependencies (28)

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Dev Dependencies (12)

                                                                                                                                                                                                                                                                                                                                                                                                                                                          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.

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