react-native-firebase/lib/index.d.ts

// Type definitions for React Native Firebase v4.2.0
// Project: https://github.com/invertase/react-native-firebase
// Definitions by: React Native Firebase Contributors
// TypeScript Version: 2.1

declare module 'react-native-firebase' {
  /** 3rd party provider Credentials */
  type AuthCredential = {
    providerId: string;
    token: string;
    secret: string;
  };

  type FirebaseModuleAndStatics<M, S = {}> = {
    (): M;
    nativeModuleExists: boolean;
  } & S;

  // Modules commented-out do not currently have type definitions
  export class Firebase {
    private constructor();
    // admob: FirebaseModuleAndStatics<RNFirebase.admob.AdMob>;
    analytics: FirebaseModuleAndStatics<RNFirebase.Analytics>;
    auth: FirebaseModuleAndStatics<
      RNFirebase.auth.Auth,
      RNFirebase.auth.AuthStatics
    >;
    // config: FirebaseModule<RNFirebase.config.Config>;
    crash: FirebaseModuleAndStatics<RNFirebase.crash.Crash>;
    crashlytics: FirebaseModuleAndStatics<RNFirebase.crashlytics.Crashlytics>;
    database: FirebaseModuleAndStatics<
      RNFirebase.database.Database,
      RNFirebase.database.DatabaseStatics
    >;
    firestore: FirebaseModuleAndStatics<
      RNFirebase.firestore.Firestore,
      RNFirebase.firestore.FirestoreStatics
    >;
    functions: FirebaseModuleAndStatics<
      RNFirebase.functions.Functions,
      RNFirebase.functions.FunctionsStatics
    >;
    iid: FirebaseModuleAndStatics<RNFirebase.iid.InstanceId>;
    // invites: FirebaseModuleAndStatics<RNFirebase.invites.Invites>
    links: FirebaseModuleAndStatics<
      RNFirebase.links.Links,
      RNFirebase.links.LinksStatics
    >;
    messaging: FirebaseModuleAndStatics<
      RNFirebase.messaging.Messaging,
      RNFirebase.messaging.MessagingStatics
    >;
    notifications: FirebaseModuleAndStatics<
      RNFirebase.notifications.Notifications,
      RNFirebase.notifications.NotificationsStatics
    >;
    // perf: FirebaseModuleAndStatics<RNFirebase.perf.Perf>;
    storage: FirebaseModuleAndStatics<RNFirebase.storage.Storage>;
    // utils: FirebaseModuleAndStatics<RNFirebase.utils.Utils>;
    initializeApp(options: Firebase.Options, name: string): App;
    app(name?: string): App;
    readonly apps: App[];
    readonly SDK_VERSION: string;
  }
  namespace Firebase {
    interface Options {
      apiKey: string;
      appId: string;
      databaseURL: string;
      messagingSenderId: string;
      projectId: string;
      storageBucket: string;
    }
  }
  const firebase: Firebase;
  export default firebase;

  // Modules commented-out do not currently have type definitions
  export class App {
    private constructor();
    // admob(): RNFirebase.admob.AdMob;
    analytics(): RNFirebase.Analytics;
    auth(): RNFirebase.auth.Auth;
    // config(): RNFirebase.config.Config;
    crash(): RNFirebase.crash.Crash;
    crashlytics(): RNFirebase.crashlytics.Crashlytics;
    database(): RNFirebase.database.Database;
    firestore(): RNFirebase.firestore.Firestore;
    functions(): RNFirebase.functions.Functions;
    iid(): RNFirebase.iid.InstanceId;
    // invites(): RNFirebase.invites.Invites;
    links(): RNFirebase.links.Links;
    messaging(): RNFirebase.messaging.Messaging;
    notifications(): RNFirebase.notifications.Notifications;
    // perf(): RNFirebase.perf.Performance;
    storage(): RNFirebase.storage.Storage;
    // utils(): RNFirebase.utils.Utils;
    readonly name: string;
    readonly options: Firebase.Options;

    onReady: () => Promise<App>;
  }

  export namespace RNFirebase {
    interface RnError extends Error {
      code?: string;
    }

    type GoogleApiAvailabilityType = {
      status: number;
      isAvailable: boolean;
      isUserResolvableError?: boolean;
      error?: string;
    };

    /**
     * pass custom options by passing an object with configuration options.
     * The configuration object will be generated first by the native configuration object, if set and then will be overridden if passed in JS.
     * That is, all of the following key/value pairs are optional if the native configuration is set.
     */
    interface configurationOptions {
      /**
       *  default false
       *  When set to true, RNFirebase will log messages to the console and fire debug events we can listen to in js
       * @usage
       * firebase.on('debug', msg => console.log('Received debug message', msg))
       */
      debug?: boolean;
      /**
       * default false
       * When set to true, database persistence will be enabled.
       */
      persistence?: boolean;
      /**
       * Default from app [NSBundle mainBundle]  The bundle ID for the app to be bundled with
       */
      bundleID?: string;
      /**
       * defualt ""
       * The Google App ID that is used to uniquely identify an instance of an app.
       */
      googleAppID?: string;
      /**
       * deufalt ""
       * The database root (i.e. https://my-app.firebaseio.com)
       */
      databaseURL?: string;
      /**
       * defualt ""
       * URL scheme to set up durable deep link service
       */
      deepLinkURLScheme?: string;
      /**
       * defualt ""
       * The Google Cloud storage bucket name
       */
      storageBucket?: string;
      /**
       * default ""
       * The Android client ID used in Google AppInvite when an iOS app has it's android version
       */
      androidClientID?: string;
      /**
       * default  ""
       * The Project number from the Google Developer's console used to configure Google Cloud Messaging
       */
      GCMSenderID?: string;
      /**
       * default ""
       * The tracking ID for Google Analytics
       */
      trackingID?: string;
      /**
       * default ""
       * The OAuth2 client ID for iOS application used to authenticate Google Users for signing in with Google
       */
      clientID?: string;
      /**
       * defualt ""
       * The secret iOS API key used for authenticating requests from our app
       */
      APIKey?: string;
    }

    namespace storage {
      interface StorageTask<T> extends Promise<T> {
        on(
          event: TaskEvent,
          nextOrObserver: (snapshot: any) => any,
          error: (error: RnError) => any,
          complete: (complete: any) => any
        ): any;

        /**
         * is not currently supported by react-native-firebase
         */
        pause(): void;

        /**
         * is not currently supported by react-native-firebase
         */
        resume(): void;

        /**
         * is not currently supported by react-native-firebase
         */
        cancel(): void;
      }

      interface RNStorage extends Reference {
        /**
         *  Downloads a reference to the device
         *  @param {String} filePath Where to store the file
         *  @return {Promise}
         * */
        downloadFile(filePath: string): StorageTask<any>;

        /**
         * Upload a file path
         * @returns {Promise}
         */
        putFile(filePath: string, metadata?: any): StorageTask<any>;

        setMaxDownloadRetryTime(time: number): void;

        [key: string]: any;
      }

      interface Storage {
        maxOperationRetryTime: number;
        maxUploadRetryTime: number;

        ref(path?: string): storage.RNStorage;

        refFromURL(url: string): storage.RNStorage;

        setMaxOperationRetryTime(time: number): any;

        setMaxUploadRetryTime(time: number): any;
      }

      interface Reference {
        bucket: string;

        child(path: string): storage.Reference;

        delete(): Promise<any>;

        fullPath: string;

        getDownloadURL(): Promise<any>;

        getMetadata(): Promise<any>;

        name: string;
        parent: storage.Reference | null;

        put(
          data: any | Uint8Array | ArrayBuffer,
          metadata?: storage.UploadMetadata
        ): storage.UploadTask;

        putString(
          data: string,
          format?: storage.StringFormat,
          metadata?: storage.UploadMetadata
        ): storage.UploadTask;

        root: storage.Reference;
        storage: storage.Storage;

        toString(): string;

        updateMetadata(metadata: storage.SettableMetadata): Promise<any>;
      }

      interface UploadMetadata extends storage.SettableMetadata {
        md5Hash?: string | null;
      }

      interface SettableMetadata {
        cacheControl?: string | null;
        contentDisposition?: string | null;
        contentEncoding?: string | null;
        contentLanguage?: string | null;
        contentType?: string | null;
        customMetadata?: {
          [/* warning: coerced from ? */ key: string]: string;
        } | null;
      }

      type StringFormat = string;
      var StringFormat: {
        BASE64: StringFormat;
        BASE64URL: StringFormat;
        DATA_URL: StringFormat;
        RAW: StringFormat;
      };

      interface UploadTask {
        cancel(): boolean;

        catch(onRejected: (a: RnError) => any): Promise<any>;

        on(
          event: storage.TaskEvent,
          nextOrObserver?: null | Object,
          error?: ((a: RnError) => any) | null,
          complete?: (() => any) | null
        ): Function;

        pause(): boolean;

        resume(): boolean;

        snapshot: storage.UploadTaskSnapshot;

        then(
          onFulfilled?: ((a: storage.UploadTaskSnapshot) => any) | null,
          onRejected?: ((a: RnError) => any) | null
        ): Promise<any>;
      }

      interface UploadTaskSnapshot {
        bytesTransferred: number;
        downloadURL: string | null;
        metadata: storage.FullMetadata;
        ref: storage.Reference;
        state: storage.TaskState;
        task: storage.UploadTask;
        totalBytes: number;
      }

      interface FullMetadata extends storage.UploadMetadata {
        bucket: string;
        downloadURLs: string[];
        fullPath: string;
        generation: string;
        metageneration: string;
        name: string;
        size: number;
        timeCreated: string;
        updated: string;
      }

      type TaskEvent = string;
      var TaskEvent: {
        STATE_CHANGED: TaskEvent;
      };

      type TaskState = string;
      var TaskState: {
        CANCELED: TaskState;
        ERROR: TaskState;
        PAUSED: TaskState;
        RUNNING: TaskState;
        SUCCESS: TaskState;
      };
    }

    namespace database {
      interface Database {
        /**
         * Returns a new firebase reference instance
         * */
        ref(path?: string): RnReference;

        /**
         * register listener
         */
        on(
          path: string,
          modifiersString: string,
          modifiers: Array<string>,
          eventName: string,
          cb: () => void,
          errorCb: () => void
        ): any;

        /**
         * unregister listener
         */
        off(
          path: string,
          modifiersString: string,
          eventName?: string,
          origCB?: () => void
        ): any;

        /**
         * Removes all event handlers and their native subscriptions
         */
        cleanup(): Promise<any>;

        /**
         * connect to firebase backend
         */
        goOnline(): void;

        /**
         * disconnect to firebase backend
         */
        goOffline(): void;

        [key: string]: any;
      }

      interface RnReference extends Reference {
        keepSynced(bool: boolean): any;

        filter(name: string, value: any, key?: string): any;

        [key: string]: any;
      }

      type QueryEventType =
        | 'value'
        | 'child_added'
        | 'child_removed'
        | 'child_changed'
        | 'child_moved';
      type QuerySuccessCallback = (
        snapshot: DataSnapshot,
        previousChildId?: string | null
      ) => void;
      type QueryErrorCallback = (e: Error) => void;

      interface Query {
        endAt(
          value: number | string | boolean | null,
          key?: string
        ): database.Query;

        equalTo(
          value: number | string | boolean | null,
          key?: string
        ): database.Query;

        isEqual(other: database.Query | null): boolean;

        limitToFirst(limit: number): database.Query;

        limitToLast(limit: number): database.Query;

        off(
          eventType?: QueryEventType,
          callback?: QuerySuccessCallback,
          context?: Object
        ): void;

        on(
          eventType: QueryEventType,
          callback: QuerySuccessCallback,
          cancelCallbackOrContext?: QueryErrorCallback,
          context?: Object
        ): (
          a: database.DataSnapshot | null,
          b?: string
        ) => QuerySuccessCallback;

        once(
          eventType: QueryEventType,
          successCallback?: QuerySuccessCallback,
          failureCallbackOrContext?: QueryErrorCallback,
          context?: Object
        ): Promise<DataSnapshot>;

        orderByChild(path: string): database.Query;

        orderByKey(): database.Query;

        orderByPriority(): database.Query;

        orderByValue(): database.Query;

        ref: database.Reference;

        startAt(
          value: number | string | boolean | null,
          key?: string
        ): database.Query;

        toJSON(): Object;

        toString(): string;
      }

      interface DataSnapshot {
        child(path: string): database.DataSnapshot;

        exists(): boolean;

        exportVal(): any;

        forEach(action: (a: database.DataSnapshot) => boolean): boolean;

        getPriority(): string | number | null;

        hasChild(path: string): boolean;

        hasChildren(): boolean;

        key: string | null;

        numChildren(): number;

        ref: database.Reference;

        toJSON(): Object | null;

        val(): any;
      }

      interface ThenableReference<T> extends Promise<T> {}

      interface ThenableReference<T> extends Reference {}

      interface Reference extends database.Query {
        child(path: string): database.Reference;

        key: string | null;

        onDisconnect(): any;

        parent: database.Reference | null;

        push(
          value?: any,
          onComplete?: (a: RnError | null) => any
        ): ThenableReference<any>;

        remove(onComplete?: (a: RnError | null) => any): Promise<any>;

        root: database.Reference;

        set(value: any, onComplete?: (a: RnError | null) => any): Promise<any>;

        setPriority(
          priority: string | number | null,
          onComplete: (a: RnError | null) => any
        ): Promise<any>;

        setWithPriority(
          newVal: any,
          newPriority: string | number | null,
          onComplete?: (a: RnError | null) => any
        ): Promise<any>;

        transaction(
          transactionUpdate: (a: any) => any,
          onComplete?: (
            a: RnError | null,
            b: boolean,
            c: database.DataSnapshot | null
          ) => any,
          applyLocally?: boolean
        ): Promise<any>;

        update(
          values: Object,
          onComplete?: (a: RnError | null) => any
        ): Promise<any>;
      }

      interface DatabaseStatics {
        /** @see https://www.firebase.com/docs/java-api/javadoc/com/firebase/client/ServerValue.html#TIMESTAMP */
        ServerValue: {
          TIMESTAMP: {
            [key: string]: string;
          };
        };
      }
    }

    /**
     * firebase Analytics
     */
    interface Analytics {
      /**Log a custom event with optional params. */
      logEvent(event: string, params?: Object): void;

      /** Sets whether analytics collection is enabled for this app on this device. */
      setAnalyticsCollectionEnabled(enabled: boolean): void;

      /**
       * Sets the current screen name, which specifies the current visual context in your app.
       * Whilst screenClassOverride is optional,
       * it is recommended it is always sent as your current class name,
       * for example on Android it will always show as 'MainActivity' if not specified.
       */
      setCurrentScreen(
        screenName: string | null,
        screenClassOverride?: string
      ): void;

      /**
       * Sets the minimum engagement time required before starting a session.
       * The default value is 10000 (10 seconds)
       */
      setMinimumSessionDuration(miliseconds: number): void;

      /**
       * Sets the duration of inactivity that terminates the current session.
       * The default value is 1800000 (30 minutes).
       */
      setSessionTimeoutDuration(miliseconds: number): void;

      /**
       * Gives a user a uniqiue identificaition.
       * @example
       * const id = firebase.auth().currentUser.uid;
       *
       * firebase.analytics().setUserId(id);
       */
      setUserId(id: string | null): void;

      /**
       * Sets a key/value pair of data on the current user.
       */
      setUserProperty(name: string, value: string | null): void;

      [key: string]: any;
    }

    type AdditionalUserInfo = {
      isNewUser: boolean;
      profile?: Object;
      providerId: string;
      username?: string;
    };

    type UserCredential = {
      additionalUserInfo?: AdditionalUserInfo;
      user: User;
    };

    type UserInfo = {
      displayName?: string;
      email?: string;
      phoneNumber?: string;
      photoURL?: string;
      providerId: string;
      uid: string;
    };

    type UpdateProfile = {
      displayName?: string;
      photoURL?: string;
    };

    type UserMetadata = {
      creationTime?: string;
      lastSignInTime?: string;
    };

    interface User {
      /**
       * The user's display name (if available).
       */
      displayName: string | null;
      /**
       * - The user's email address (if available).
       */
      email: string | null;
      /**
       * - True if the user's email address has been verified.
       */
      emailVerified: boolean;
      /**
       *
       */
      isAnonymous: boolean;

      metadata: UserMetadata;

      phoneNumber: string | null;
      /**
       * - The URL of the user's profile picture (if available).
       */
      photoURL: string | null;
      /**
       * - Additional provider-specific information about the user.
       */
      providerData: Array<UserInfo>;
      /**
       *  - The authentication provider ID for the current user.
       *  For example, 'facebook.com', or 'google.com'.
       */
      providerId: string;
      /**
       *  - The user's unique ID.
       */
      uid: string;

      /**
       * Delete the current user.
       */
      delete(): Promise<void>;

      /**
       * Returns the users authentication token.
       *
       * @param forceRefresh: boolean - default to false
       */
      getIdToken(forceRefresh?: boolean): Promise<string>;

      getToken(forceRefresh?: boolean): Promise<string>;

      linkAndRetrieveDataWithCredential(
        credential: AuthCredential
      ): Promise<UserCredential>;

      /**
       * Link the user with a 3rd party credential provider.
       */
      linkWithCredential(credential: AuthCredential): Promise<User>;

      reauthenticateAndRetrieveDataWithCredential(
        credential: AuthCredential
      ): Promise<UserCredential>;

      /**
       * Re-authenticate a user with a third-party authentication provider
       */
      reauthenticateWithCredential(credential: AuthCredential): Promise<void>;

      /**
       * Refreshes the current user.
       */
      reload(): Promise<void>;

      /**
       * Sends a verification email to a user.
       * This will Promise reject is the user is anonymous.
       */
      sendEmailVerification(
        actionCodeSettings?: ActionCodeSettings
      ): Promise<void>;

      toJSON(): object;

      unlink(providerId: string): Promise<User>;

      /**
       * Updates the user's email address.
       * See Firebase docs for more information on security & email validation.
       * This will Promise reject is the user is anonymous.
       */
      updateEmail(email: string): Promise<void>;

      /**
       * 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#reauthenticate.
       * This will Promise reject is the user is anonymous.
       */
      updatePassword(password: string): Promise<void>;

      /**
       * Updates a user's profile data.
       * Profile data should be an object of fields to update:
       */
      updateProfile(updates: UpdateProfile): Promise<void>;
    }

    type ActionCodeSettings = {
      android: {
        installApp?: boolean;
        minimumVersion?: string;
        packageName: string;
      };
      handleCodeInApp?: boolean;
      iOS: {
        bundleId?: string;
      };
      url: string;
    };

    interface ActionCodeInfo {
      data: {
        email?: string;
        fromEmail?: string;
      };
      operation: 'PASSWORD_RESET' | 'VERIFY_EMAIL' | 'RECOVER_EMAIL';
    }

    interface ConfirmationResult {
      confirm(verificationCode: string): Promise<User | null>;

      verificationId: string | null;
    }

    type PhoneAuthSnapshot = {
      state: 'sent' | 'timeout' | 'verified' | 'error';
      verificationId: string;
      code: string | null;
      error: Error | null;
    };

    type PhoneAuthError = {
      code: string | null;
      verificationId: string;
      message: string | null;
      stack: string | null;
    };

    interface PhoneAuthListener {
      on(
        event: string,
        observer: () => PhoneAuthSnapshot,
        errorCb?: () => PhoneAuthError,
        successCb?: () => PhoneAuthSnapshot
      ): PhoneAuthListener;

      then(fn: () => PhoneAuthSnapshot): Promise<any>;

      catch(fn: () => Error): Promise<any>;
    }

    namespace auth {
      type AuthResult = {
        authenticated: boolean;
        user: object | null;
      } | null;

      type AuthProvider = {
        PROVIDER_ID: string;
        credential: (token: string, secret?: string) => AuthCredential;
      };

      type EmailAuthProvider = {
        PROVIDER_ID: string;
        EMAIL_LINK_SIGN_IN_METHOD: string;
        EMAIL_PASSWORD_SIGN_IN_METHOD: string;
        credential: (email: string, password: string) => AuthCredential;
        credentialWithLink: (email: string, emailLink: string) => AuthCredential;
      };

      interface Auth {
        readonly app: App;
        /**
         * Returns the current Firebase authentication state.
         */
        authResult: AuthResult | null;
        /**
         * Returns the currently signed-in user (or null). See the User class documentation for further usage.
         */
        currentUser: User | null;

        /**
         * Gets/Sets the language for the app instance
         */
        languageCode: string | null;

        /**
         * Listen for changes in the users auth state (logging in and out).
         * This method returns a unsubscribe function to stop listening to events.
         * Always ensure you unsubscribe from the listener when no longer needed to prevent updates to components no longer in use.
         */
        onAuthStateChanged(listener: Function): () => void;

        /**
         * Listen for changes in id token.
         * This method returns a unsubscribe function to stop listening to events.
         * Always ensure you unsubscribe from the listener when no longer needed to prevent updates to components no longer in use.
         */
        onIdTokenChanged(listener: Function): () => void;

        /**
         * Listen for changes in the user.
         * This method returns a unsubscribe function to stop listening to events.
         * Always ensure you unsubscribe from the listener when no longer needed to prevent updates to components no longer in use.
         */
        onUserChanged(listener: Function): () => void;

        signOut(): Promise<void>;

        signInAnonymouslyAndRetrieveData(): Promise<UserCredential>;

        /**
         * Sign an anonymous user.
         * If the user has already signed in, that user will be returned
         */
        signInAnonymously(): Promise<User>;

        createUserAndRetrieveDataWithEmailAndPassword(
          email: string,
          password: string
        ): Promise<UserCredential>;

        signInWithEmailLink(
          email: string,
          emailLink: string
        ): Promise<UserCredential>;

        isSignInWithEmailLink(emailLink: string): boolean;

        /**
         * We can create a user by calling the createUserWithEmailAndPassword() function.
         * The method accepts two parameters, an email and a password.
         */
        createUserWithEmailAndPassword(
          email: string,
          password: string
        ): Promise<User>;

        signInAndRetrieveDataWithEmailAndPassword(
          email: string,
          password: string
        ): Promise<UserCredential>;

        /**
         * To sign a user in with their email and password, use the signInWithEmailAndPassword() function.
         * It accepts two parameters, the user's email and password:
         */
        signInWithEmailAndPassword(
          email: string,
          password: string
        ): Promise<User>;

        signInAndRetrieveDataWithCustomToken(
          token: string
        ): Promise<UserCredential>;

        /**
         * Sign a user in with a self-signed JWT token.
         * To sign a user using a self-signed custom token,
         * use the signInWithCustomToken() function.
         * It accepts one parameter, the custom token:
         */
        signInWithCustomToken(token: string): Promise<User>;

        signInAndRetrieveDataWithCredential(
          credential: AuthCredential
        ): Promise<UserCredential>;

        /**
         * Sign in the user with a 3rd party credential provider.
         * credential requires the following properties:
         */
        signInWithCredential(credential: AuthCredential): Promise<User>;

        /**
         * Asynchronously signs in using a phone number.
         */
        signInWithPhoneNumber(phoneNumber: string): Promise<ConfirmationResult>;

        /**
         * Returns a PhoneAuthListener to listen to phone verification events,
         * on the final completion event a PhoneAuthCredential can be generated for
         * authentication purposes.
         */
        verifyPhoneNumber(
          phoneNumber: string,
          autoVerifyTimeout?: number
        ): PhoneAuthListener;

        /**
         * Sends a password reset email to the given email address.
         * Unlike the web SDK,
         * the email will contain a password reset link rather than a code.
         */
        sendPasswordResetEmail(
          email: string,
          actionCodeSettings?: ActionCodeSettings
        ): Promise<void>;

        sendSignInLinkToEmail(
          email: string,
          actionCodeSettings?: ActionCodeSettings
        ): Promise<void>;

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

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

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

        /**
         * Returns a list of authentication providers that can be used to sign in a given user (identified by its main email address).
         */
        fetchProvidersForEmail(email: string): Promise<Array<string>>;

        verifyPasswordResetCode(code: string): Promise<string>;

        [key: string]: any;
      }

      interface AuthStatics {
        EmailAuthProvider: EmailAuthProvider;
        PhoneAuthProvider: AuthProvider;
        GoogleAuthProvider: AuthProvider;
        GithubAuthProvider: AuthProvider;
        OAuthProvider: AuthProvider;
        TwitterAuthProvider: AuthProvider;
        FacebookAuthProvider: AuthProvider;
        PhoneAuthState: {
          CODE_SENT: string;
          AUTO_VERIFY_TIMEOUT: string;
          AUTO_VERIFIED: string;
          ERROR: string;
        };
      }
    }

    namespace messaging {
      interface Messaging {
        /**
         * Returns the devices FCM token.
         */
        getToken(): Promise<string>;

        /**
         * On a new message,
         * the payload object is passed to the listener callback.
         * This method is only triggered when the app is running.
         */
        onMessage(listener: (message: any) => any): () => any;

        /**
         * On the event a devices FCM token is refreshed by Google,
         *  the new token is returned in a callback listener.
         */
        onTokenRefresh(listener: (token: string) => any): () => any;

        /**
         * Requests app notification permissions in an Alert dialog.
         */
        requestPermission(): Promise<boolean>;

        /**
         * Checks if the app has notification permissions.
         */
        hasPermission(): Promise<boolean>;

        /**
         * Send an upstream message
         */
        sendMessage(remoteMessage: RemoteMessage): Promise<void>;

        /**
         * Subscribes the device to a topic.
         */
        subscribeToTopic(topic: string): void;

        /**
         * Unsubscribes the device from a topic.
         */
        unsubscribeFromTopic(topic: string): void;
      }

      class RemoteMessage {
        collapseKey?: string;
        data: Object;
        from?: string;
        messageId?: string;
        messageType: string;
        sentTime?: number;
        to?: string;
        ttl?: number;

        constructor();

        setCollapseKey(collapseKey: string): RemoteMessage;
        setData(data: Object): RemoteMessage;
        setMessageId(messageId: string): RemoteMessage;
        setMessageType(messageType: string): RemoteMessage;
        setTo(to: string): RemoteMessage;
        setTtl(ttl: number): RemoteMessage;
      }

      interface MessagingStatics {
        RemoteMessage: typeof RemoteMessage;
      }
    }

    namespace iid {
      interface InstanceId {
        delete(): Promise<void>;
        get(): Promise<string>;
      }
    }

    namespace notifications {
      interface AndroidNotifications {
        createChannel(channel: Android.Channel): Promise<void>;
        createChannelGroup(channelGroup: Android.ChannelGroup): Promise<void>;
        createChannelGroups(
          channelGroups: Android.ChannelGroup[]
        ): Promise<void>;
        createChannels(channels: Android.Channel[]): Promise<void>;
        deleteChannelGroup(groupId: string): Promise<void>;
        deleteChannel(channelId: string): Promise<void>;
      }

      interface Notifications {
        android: AndroidNotifications;

        /**
         * Cancels all notifications
         */
        cancelAllNotifications(): void;

        /**
         * Cancels a notification by ID
         */
        cancelNotification(notificationId: string): void;

        displayNotification(notification: Notification): Promise<void>;

        /**
         * Returns the current badge number on the app icon.
         */
        getBadge(): Promise<number>;

        getInitialNotification(): Promise<NotificationOpen>;

        getScheduledNotifications(): Promise<Notification[]>;

        onNotification(
          listener: (notification: Notification) => any
        ): () => any;

        onNotificationDisplayed(
          listener: (notification: Notification) => any
        ): () => any;

        onNotificationOpened(
          listener: (notificationOpen: NotificationOpen) => any
        ): () => any;

        removeAllDeliveredNotifications(): void;

        removeDeliveredNotification(notificationId: string): void;

        /**
         * Schedule a local notification to be shown on the device.
         */
        scheduleNotification(notification: Notification, schedule: any): any;

        /**
         * Sets the badge number on the iOS app icon.
         */
        setBadge(badge: number): void;
      }

      class Notification {
        android: AndroidNotification;
        ios: IOSNotification;
        body: string;
        data: any;
        notificationId: string;
        sound?: string;
        subtitle?: string;
        title: string;

        constructor();

        setBody(body: string): Notification;
        setData(data: any): Notification;
        setNotificationId(notificationId: string): Notification;
        setSound(sound: string): Notification;
        setSubtitle(subtitle: string): Notification;
        setTitle(title: string): Notification;
      }

      class NotificationOpen {
        action: string;
        notification: Notification;
        results?: any;
      }

      class AndroidNotification {
        actions?: Android.Action[];
        autoCancel?: boolean;
        badgeIconType?: Android.BadgeIconType;
        bigPicture?: any;
        bigText?: any;
        category?: Android.Category;
        channelId?: string;
        clickAction?: string;
        color?: string;
        colorized?: boolean;
        contentInfo?: string;
        defaults?: Android.Defaults[];
        group?: string;
        groupAlertBehaviour?: Android.GroupAlert;
        groupSummary?: boolean;
        largeIcon?: string;
        lights?: Android.Lights;
        localOnly?: boolean;
        number?: number;
        ongoing?: boolean;
        onlyAlertOnce?: boolean;
        people?: string[];
        priority?: Android.Priority;
        progress?: Android.Progress;
        remoteInputHistory?: string[];
        shortcutId?: string;
        showWhen?: boolean;
        smallIcon?: any;
        sortKey?: string;
        ticker?: string;
        timeoutAfter?: number;
        usesChronometer?: boolean;
        vibrate?: number[];
        visibility?: Android.Visibility;
        when?: number;

        addAction(action: Android.Action): Notification;
        addPerson(person: string): Notification;
        setAutoCancel(autoCancel: boolean): Notification;
        setBadgeIconType(badgeIconType: Android.BadgeIconType): Notification;
        setBigPicture(
          picture: string,
          largeIcon?: string,
          contentTitle?: string,
          summaryText?: string
        ): Notification;
        setBigText(
          text: string,
          contentTitle?: string,
          summaryText?: string
        ): Notification;
        setCategory(category: Android.Category): Notification;
        setChannelId(channelId: string): Notification;
        setClickAction(clickAction: string): Notification;
        setColor(color: string): Notification;
        setColorized(colorized: boolean): Notification;
        setContentInfo(contentInfo: string): Notification;
        setDefaults(defaults: Android.Defaults[]): Notification;
        setGroup(group: string): Notification;
        setGroupAlertBehaviour(
          groupAlertBehaviour: Android.GroupAlert
        ): Notification;
        setGroupSummary(groupSummary: boolean): Notification;
        setLargeIcon(largeIcon: string): Notification;
        setLights(argb: number, onMs: number, offMs: number): Notification;
        setLocalOnly(localOnly: boolean): Notification;
        setNumber(number: number): Notification;
        setOngoing(ongoing: boolean): Notification;
        setOnlyAlertOnce(onlyAlertOnce: boolean): Notification;
        setPriority(priority: Android.Priority): Notification;
        setProgress(
          max: number,
          progress: number,
          indeterminate: boolean
        ): Notification;
        //setPublicVersion(publicVersion: Notification): Notification
        setRemoteInputHistory(remoteInputHistory: string[]): Notification;
        setShortcutId(shortcutId: string): Notification;
        setShowWhen(showWhen: boolean): Notification;
        setSmallIcon(icon: string, level?: number): Notification;
        setSortKey(sortKey: string): Notification;
        setTicker(ticker: string): Notification;
        setTimeoutAfter(timeoutAfter: number): Notification;
        setUsesChronometer(usesChronometer: boolean): Notification;
        setVibrate(vibrate: number[]): Notification;
        setVisibility(visibility: Android.Visibility): Notification;
        setWhen(when: number): Notification;
      }

      namespace Android {
        class Action {
          action: string;
          allowGeneratedReplies: boolean;
          icon: string;
          remoteInputs: RemoteInput[];
          semanticAction?: SemanticAction;
          showUserInterface?: boolean;
          title: string;
          runInBackground?: boolean;

          constructor(action: string, icon: string, title: string);

          addRemoteInput(remoteInput: RemoteInput): Action;
          setAllowGenerateReplies(allowGeneratedReplies: boolean): Action;
          setSemanticAction(semanticAction: SemanticAction): Action;
          setShowUserInterface(showUserInterface: boolean): Action;
          setRunInBackground(runInBackground: boolean): Action;
        }

        class RemoteInput {
          allowedDataTypes: any[];
          allowFreeFormInput?: boolean;
          choices: string[];
          label?: string;
          resultKey: string;

          constructor(resultKey: string);

          setAllowDataType(mimeType: string, allow: boolean): RemoteInput;
          setAllowFreeFormInput(allowFreeFormInput: boolean): RemoteInput;
          setChoices(choices: string[]): RemoteInput;
          setLabel(label: string): RemoteInput;
        }

        class Channel {
          channelId: string;
          name: string;
          importance: Importance;

          bypassDnd?: boolean;
          description?: string;
          group?: string;
          lightColor?: string;
          lightsEnabled?: boolean;
          lockScreenVisibility?: Visibility;
          showBadge?: boolean;
          sound?: string;
          vibrationEnabled?: boolean;
          vibrationPattern?: number[];

          constructor(channelId: string, name: string, importance: Importance);

          enableLights(lightsEnabled: boolean): Channel;
          enableVibration(vibrationEnabled: boolean): Channel;
          setBypassDnd(bypassDnd: boolean): Channel;
          setDescription(description: string): Channel;
          setGroup(groupId: string): Channel;
          setLightColor(lightColor: string): Channel;
          setLockScreenVisibility(lockScreenVisibility: Visibility): Channel;
          setShowBadge(showBadge: boolean): Channel;
          setSound(sound: string): Channel;
          setVibrationPattern(vibrationPattern: number[]): Channel;
        }

        class ChannelGroup {
          groupId: string;
          name: string;

          constructor(groupId: string, name: string);
        }

        export enum BadgeIconType {
          Large = 2,
          None = 0,
          Small = 1,
        }

        export type Category =
          | 'alarm'
          | 'call'
          | 'email'
          | 'err'
          | 'event'
          | 'msg'
          | 'progress'
          | 'promo'
          | 'recommendation'
          | 'reminder'
          | 'service'
          | 'social'
          | 'status'
          | 'system'
          | 'transport';

        export enum Defaults {
          All = -1,
          Lights = 4,
          Sound = 1,
          Vibrate = 2,
        }

        export enum GroupAlert {
          All = 0,
          Children = 2,
          Summary = 1,
        }

        export enum Importance {
          Default = 3,
          High = 4,
          Low = 2,
          Max = 5,
          Min = 1,
          None = 3,
          Unspecified = -1000,
        }

        export enum Priority {
          Default = 0,
          High = 1,
          Low = -1,
          Max = 2,
          Min = -2,
        }

        export enum SemanticAction {
          Archive = 5,
          Call = 10,
          Delete = 4,
          MarkAsRead = 2,
          MarkAsUnread = 3,
          Mute = 6,
          None = 0,
          Reply = 1,
          ThumbsDown = 9,
          ThumbsUp = 8,
          Unmute = 7,
        }

        export enum Visibility {
          Private = 0,
          Public = 1,
          Secret = -1,
        }

        class Lights {
          argb: number;
          offMs: number;
          onMs: number;
        }

        class Progress {
          indeterminate: boolean;
          max: number;
          progress: number;
        }
      }

      class IOSNotification {
        alertAction?: string;
        attachments: IOSAttachment[];
        badge?: string;
        category?: string;
        hasAction?: boolean;
        launchImage?: string;
        threadIdentifier?: string;

        addAttachment(
          identifier: string,
          url: string,
          options: IOSAttachmentOptions
        ): Notification;
        setAlertAction(alertAction: string): Notification;
        setBadge(badge: string): Notification;
        setCategory(category: string): Notification;
        setHasAction(hasAction: boolean): Notification;
        setLaunchImage(launchImage: string): Notification;
        setThreadIdentifier(threadIdentifier: string): Notification;
      }

      class IOSAttachment {
        identifier: string;
        options: IOSAttachmentOptions;
        url: string;
      }

      class IOSAttachmentOptions {
        typeHint: string;
        thumbnailHidden: boolean;
        thumbnailClippingRect: any;
        thumbnailTime: string;
      }

      interface NotificationsStatics {
        Android: {
          Action: typeof Android.Action;
          BadgeIconType: typeof Android.BadgeIconType;
          Category: Android.Category;
          Channel: typeof Android.Channel;
          ChannelGroup: typeof Android.ChannelGroup;
          Defaults: typeof Android.Defaults;
          GroupAlert: typeof Android.GroupAlert;
          Importance: typeof Android.Importance;
          Priority: typeof Android.Priority;
          RemoteInput: typeof Android.RemoteInput;
          SemanticAction: typeof Android.SemanticAction;
          Visibility: typeof Android.Visibility;
        };
        Notification: typeof Notification;
      }
    }

    namespace crash {
      interface Crash {
        /** Logs a message that will appear in a subsequent crash report. */
        log(message: string): void;

        /**
         * Android: Logs a message that will appear in a subsequent crash report as well as in logcat.
         * iOS: Logs the message in the subsequest crash report only (same as log).
         */
        logcat(level: number, tag: string, message: string): void;

        /**
         * Files a crash report, along with any previous logs to Firebase.
         * An Error object must be passed into the report method.
         */
        report(error: RnError, maxStackSize: Number): void;

        [key: string]: any;
      }
    }

    namespace crashlytics {
      interface Crashlytics {
        /**
         * Forces a crash. Useful for testing your application is set up correctly.
         */
        crash(): void;

        /**
         * Logs a message that will appear in any subsequent crash reports.
         */
        log(message: string): void;

        /**
         * Logs a non fatal exception.
         */
        recordError(code: number, message: string): void;

        /**
         * Set a boolean value to show alongside any subsequent crash reports.
         */
        setBoolValue(key: string, value: boolean): void;

        /**
         * Set a float value to show alongside any subsequent crash reports.
         */
        setFloatValue(key: string, value: number): void;

        /**
         * Set an integer value to show alongside any subsequent crash reports.
         */
        setIntValue(key: string, value: number): void;

        /**
         * Set a string value to show alongside any subsequent crash reports.
         */
        setStringValue(key: string, value: string): void;

        /**
         * Set the user ID to show alongside any subsequent crash reports.
         */
        setUserIdentifier(userId: string): void;
      }
    }

    namespace links {
      interface Links {
        /** Creates a standard dynamic link. */
        createDynamicLink(dynamicLink: DynamicLink): Promise<string>;
        /** Creates a short dynamic link. */
        createShortDynamicLink(type: 'SHORT' | 'UNGUESSABLE'): Promise<string>;
        /**
         * Returns the URL that the app has been launched from. If the app was
         * not launched from a URL the return value will be null.
         */
        getInitialLink(): Promise<string | null>;
        /**
         * Subscribe to URL open events while the app is still running.
         * The listener is called from URL open events whilst the app is still
         * running, use getInitialLink for URLs which cause the app to open
         * from a previously closed / not running state.
         * Returns an unsubscribe function, call the returned function to
         * unsubscribe from all future events.
         */
        onLink(listener: (url: string) => void): () => void;
      }

      class DynamicLink {
        analytics: AnalyticsParameters;
        android: AndroidParameters;
        ios: IOSParameters;
        itunes: ITunesParameters;
        navigation: NavigationParameters;
        social: SocialParameters;

        constructor(link: string, dynamicLinkDomain: string);
      }

      interface AnalyticsParameters {
        setCampaign(campaign: string): DynamicLink;
        setContent(content: string): DynamicLink;
        setMedium(medium: string): DynamicLink;
        setSource(source: string): DynamicLink;
        setTerm(term: string): DynamicLink;
      }

      interface AndroidParameters {
        setFallbackUrl(fallbackUrl: string): DynamicLink;
        setMinimumVersion(minimumVersion: number): DynamicLink;
        setPackageName(packageName: string): DynamicLink;
      }

      interface IOSParameters {
        setAppStoreId(appStoreId: string): DynamicLink;
        setBundleId(bundleId: string): DynamicLink;
        setCustomScheme(customScheme: string): DynamicLink;
        setFallbackUrl(fallbackUrl: string): DynamicLink;
        setIPadBundleId(iPadBundleId: string): DynamicLink;
        setIPadFallbackUrl(iPadFallbackUrl: string): DynamicLink;
        setMinimumVersion(minimumVersion: string): DynamicLink;
      }

      interface ITunesParameters {
        setAffiliateToken(affiliateToken: string): DynamicLink;
        setCampaignToken(campaignToken: string): DynamicLink;
        setProviderToken(providerToken: string): DynamicLink;
      }

      interface NavigationParameters {
        setForcedRedirectEnabled(forcedRedirectEnabled: boolean): DynamicLink;
      }

      interface SocialParameters {
        setDescriptionText(descriptionText: string): DynamicLink;
        setImageUrl(imageUrl: string): DynamicLink;
        setTitle(title: string): DynamicLink;
      }

      interface LinksStatics {
        DynamicLink: typeof DynamicLink;
      }
    }

    // Source: https://github.com/firebase/firebase-js-sdk/blob/master/packages/functions-types/index.d.ts
    namespace functions {
      type HttpsErrorCode = { [name: string]: FunctionsErrorCode };

      /**
       * 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.
       */
      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';

      /**
       * An HttpsCallableResult wraps a single result from a function call.
       */
      interface HttpsCallableResult {
        readonly data: any;
      }

      /**
       * An HttpsCallable is a reference to a "callable" http trigger in
       * Google Cloud Functions.
       */
      interface HttpsCallable {
        (data?: any): Promise<HttpsCallableResult>;
      }

      /**
       * `FirebaseFunctions` represents a Functions app, and is the entry point for
       * all Functions operations.
       */
      interface Functions {
        /**
         * Gets an `HttpsCallable` instance that refers to the function with the given
         * name.
         *
         * @param name The name of the https callable function.
         * @return The `HttpsCallable` instance.
         */
        httpsCallable(name: string): HttpsCallable;
      }

      /**
       * firebase.functions.X
       */
      interface FunctionsStatics {
        /**
         * Uppercased + underscored variables of @FunctionsErrorCode
         */
        HttpsErrorCode: HttpsErrorCode;
      }

      interface HttpsError extends Error {
        /**
         * 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.
         */
        readonly code: FunctionsErrorCode;
        /**
         * Extra data to be converted to JSON and included in the error response.
         */
        readonly details?: any;
      }
    }

    namespace firestore {
      interface Firestore {
        readonly app: App;
        batch(): WriteBatch;
        collection(collectionPath: string): CollectionReference;
        disableNetwork(): Promise<void>;
        doc(documentPath: string): DocumentReference;
        enableNetwork(): Promise<void>;
        enablePersistence(enabled: boolean): Promise<void>;
        runTransaction(
          updateFunction: (transaction: Transaction) => Promise<any>
        ): Promise<any>;
        settings(settings: Settings): Promise<void>;
      }

      interface FirestoreStatics {
        Blob: typeof Blob;
        FieldPath: typeof FieldPath;
        FieldValue: typeof FieldValue;
        GeoPoint: typeof GeoPoint;
        enableLogging(enabled: boolean): void;
        setLogLevel(logLevel: 'debug' | 'error' | 'silent'): void;
      }

      interface CollectionReference {
        readonly firestore: Firestore;
        readonly id: string;
        readonly parent: DocumentReference;
        add(data: object): Promise<DocumentReference>;
        doc(documentPath?: string): DocumentReference;
        endAt(snapshot: DocumentSnapshot): Query;
        endAt(...varargs: any[]): Query;
        endBefore(snapshot: DocumentSnapshot): Query;
        endBefore(...varargs: any[]): Query;
        get(): Promise<QuerySnapshot>;
        limit(limit: number): Query;
        onSnapshot(
          onNext: Query.ObserverOnNext,
          onError?: Query.ObserverOnError
        ): () => void;
        onSnapshot(observer: Query.Observer): () => void;
        onSnapshot(
          metadataChanges: MetadataChanges,
          onNext: Query.ObserverOnNext,
          onError?: Query.ObserverOnError
        ): () => void;
        onSnapshot(
          metadataChanges: MetadataChanges,
          observer: Query.Observer
        ): () => void;
        orderBy(
          fieldPath: string | FieldPath,
          directionStr?: Types.QueryDirection
        ): Query;
        startAfter(snapshot: DocumentSnapshot): Query;
        startAfter(...varargs: any[]): Query;
        startAt(snapshot: DocumentSnapshot): Query;
        startAt(...varargs: any[]): Query;
        where(
          fieldPath: string | FieldPath,
          op: Types.QueryOperator,
          value: any
        ): Query;
      }

      interface DocumentChange {
        readonly doc: DocumentSnapshot;
        readonly newIndex: number;
        readonly oldIndex: number;
        readonly type: string;
      }

      interface DocumentReference {
        readonly firestore: Firestore;
        readonly id: string | null;
        readonly parent: CollectionReference;
        readonly path: string;
        collection(collectionPath: string): CollectionReference;
        delete(): Promise<void>;
        get(): Promise<DocumentSnapshot>;
        onSnapshot(
          onNext: DocumentReference.ObserverOnNext,
          onError?: DocumentReference.ObserverOnError
        ): () => void;
        onSnapshot(observer: DocumentReference.Observer): () => void;
        onSnapshot(
          metadataChanges: MetadataChanges,
          onNext: DocumentReference.ObserverOnNext,
          onError?: DocumentReference.ObserverOnError
        ): () => void;
        onSnapshot(
          metadataChanges: MetadataChanges,
          observer: DocumentReference.Observer
        ): () => void;
        set(data: object, writeOptions?: Types.WriteOptions): Promise<void>;
        update(obj: object): Promise<void>;
        update(key1: Types.UpdateKey, val1: any): Promise<void>;
        update(
          key1: Types.UpdateKey,
          val1: any,
          key2: Types.UpdateKey,
          val2: any
        ): Promise<void>;
        update(
          key1: Types.UpdateKey,
          val1: any,
          key2: Types.UpdateKey,
          val2: any,
          key3: Types.UpdateKey,
          val3: any
        ): Promise<void>;
        update(
          key1: Types.UpdateKey,
          val1: any,
          key2: Types.UpdateKey,
          val2: any,
          key3: Types.UpdateKey,
          val3: any,
          key4: Types.UpdateKey,
          val4: any
        ): Promise<void>;
        update(
          key1: Types.UpdateKey,
          val1: any,
          key2: Types.UpdateKey,
          val2: any,
          key3: Types.UpdateKey,
          val3: any,
          key4: Types.UpdateKey,
          val4: any,
          key5: Types.UpdateKey,
          val5: any
        ): Promise<void>;
      }
      namespace DocumentReference {
        type ObserverOnNext = (documentSnapshot: DocumentSnapshot) => void;
        type ObserverOnError = (err: object) => void;
        interface Observer {
          next: ObserverOnNext;
          error?: ObserverOnError;
        }
      }

      interface DocumentSnapshot {
        readonly exists: boolean;
        readonly id: string | null;
        readonly metadata: Types.SnapshotMetadata;
        readonly ref: DocumentReference;
        data(): object | void;
        get(fieldPath: string | FieldPath): any | undefined;
      }

      class Blob {
        static fromBase64String(base64: string): Blob;
        static fromUint8Array(array: Uint8Array): Blob;
        isEqual(other: Blob): boolean;
        toBase64(): string;
        toUint8Array: Uint8Array;
      }

      class FieldPath {
        static documentId(): FieldPath;
        constructor(...segments: string[]);
      }

      class FieldValue {
        static delete(): FieldValue;
        static serverTimestamp(): FieldValue;
      }

      class GeoPoint {
        constructor(latitude: number, longitude: number);
        readonly latitude: number;
        readonly longitude: number;
      }

      class Path {
        static fromName(name: string): Path;
        constructor(pathComponents: string[]);
        readonly id: string | null;
        readonly isDocument: boolean;
        readonly isCollection: boolean;
        readonly relativeName: string;
        child(relativePath: string): Path;
        parent(): Path | null;
      }

      type MetadataChanges = {
        includeMetadataChanges: boolean;
      };

      interface Query {
        readonly firestore: Firestore;
        endAt(snapshot: DocumentSnapshot): Query;
        endAt(...varargs: any[]): Query;
        endBefore(snapshot: DocumentSnapshot): Query;
        endBefore(...varargs: any[]): Query;
        get(): Promise<QuerySnapshot>;
        limit(limit: number): Query;
        onSnapshot(
          onNext: Query.ObserverOnNext,
          onError?: Query.ObserverOnError
        ): () => void;
        onSnapshot(observer: Query.Observer): () => void;
        onSnapshot(
          metadataChanges: MetadataChanges,
          onNext: Query.ObserverOnNext,
          onError?: Query.ObserverOnError
        ): () => void;
        onSnapshot(
          metadataChanges: MetadataChanges,
          observer: Query.Observer
        ): () => void;
        orderBy(
          fieldPath: string | FieldPath,
          directionStr?: Types.QueryDirection
        ): Query;
        startAfter(snapshot: DocumentSnapshot): Query;
        startAfter(...varargs: any[]): Query;
        startAt(snapshot: DocumentSnapshot): Query;
        startAt(...varargs: any[]): Query;
        where(
          fieldPath: string | FieldPath,
          op: Types.QueryOperator,
          value: any
        ): Query;
      }
      namespace Query {
        interface NativeFieldPath {
          elements?: string[];
          string?: string;
          type: 'fieldpath' | 'string';
        }

        interface FieldFilter {
          fieldPath: NativeFieldPath;
          operator: string;
          value: any;
        }

        interface FieldOrder {
          direction: string;
          fieldPath: NativeFieldPath;
        }

        interface QueryOptions {
          endAt?: any[];
          endBefore?: any[];
          limit?: number;
          offset?: number;
          selectFields?: string[];
          startAfter?: any[];
          startAt?: any[];
        }

        type ObserverOnNext = (querySnapshot: QuerySnapshot) => void;
        type ObserverOnError = (err: object) => void;
        interface Observer {
          next: ObserverOnNext;
          error?: ObserverOnError;
        }
      }

      interface QuerySnapshot {
        readonly docChanges: DocumentChange[];
        readonly docs: DocumentSnapshot[];
        readonly empty: boolean;
        readonly metadata: Types.SnapshotMetadata;
        readonly query: Query;
        readonly size: number;
        forEach(callback: (snapshot: DocumentSnapshot) => any): void;
      }
      namespace QuerySnapshot {
        interface NativeData {
          changes: Types.NativeDocumentChange[];
          documents: Types.NativeDocumentSnapshot[];
          metadata: Types.SnapshotMetadata;
        }
      }

      interface Settings {
        host?: string;
        persistence?: boolean;
        ssl?: boolean;
        timestampsInSnapshots?: boolean;
      }

      interface Transaction {
        delete(docRef: DocumentReference): WriteBatch;
        get(documentRef: DocumentReference): Promise<DocumentSnapshot>;
        set(
          documentRef: DocumentReference,
          data: Object,
          options?: Types.WriteOptions
        ): Transaction;
        // multiple overrides for update() to allow strong-typed var_args
        update(docRef: DocumentReference, obj: object): WriteBatch;
        update(
          docRef: DocumentReference,
          key1: Types.UpdateKey,
          val1: any
        ): WriteBatch;
        update(
          docRef: DocumentReference,
          key1: Types.UpdateKey,
          val1: any,
          key2: Types.UpdateKey,
          val2: any
        ): WriteBatch;
        update(
          docRef: DocumentReference,
          key1: Types.UpdateKey,
          val1: any,
          key2: Types.UpdateKey,
          val2: any,
          key3: Types.UpdateKey,
          val3: any
        ): WriteBatch;
        update(
          docRef: DocumentReference,
          key1: Types.UpdateKey,
          val1: any,
          key2: Types.UpdateKey,
          val2: any,
          key3: Types.UpdateKey,
          val3: any,
          key4: Types.UpdateKey,
          val4: any
        ): WriteBatch;
        update(
          docRef: DocumentReference,
          key1: Types.UpdateKey,
          val1: any,
          key2: Types.UpdateKey,
          val2: any,
          key3: Types.UpdateKey,
          val3: any,
          key4: Types.UpdateKey,
          val4: any,
          key5: Types.UpdateKey,
          val5: any
        ): WriteBatch;
      }

      interface WriteBatch {
        commit(): Promise<void>;
        delete(docRef: DocumentReference): WriteBatch;
        set(
          docRef: DocumentReference,
          data: object,
          options?: Types.WriteOptions
        ): WriteBatch;
        // multiple overrides for update() to allow strong-typed var_args
        update(docRef: DocumentReference, obj: object): WriteBatch;
        update(
          docRef: DocumentReference,
          key1: Types.UpdateKey,
          val1: any
        ): WriteBatch;
        update(
          docRef: DocumentReference,
          key1: Types.UpdateKey,
          val1: any,
          key2: Types.UpdateKey,
          val2: any
        ): WriteBatch;
        update(
          docRef: DocumentReference,
          key1: Types.UpdateKey,
          val1: any,
          key2: Types.UpdateKey,
          val2: any,
          key3: Types.UpdateKey,
          val3: any
        ): WriteBatch;
        update(
          docRef: DocumentReference,
          key1: Types.UpdateKey,
          val1: any,
          key2: Types.UpdateKey,
          val2: any,
          key3: Types.UpdateKey,
          val3: any,
          key4: Types.UpdateKey,
          val4: any
        ): WriteBatch;
        update(
          docRef: DocumentReference,
          key1: Types.UpdateKey,
          val1: any,
          key2: Types.UpdateKey,
          val2: any,
          key3: Types.UpdateKey,
          val3: any,
          key4: Types.UpdateKey,
          val4: any,
          key5: Types.UpdateKey,
          val5: any
        ): WriteBatch;
      }

      namespace Types {
        interface NativeDocumentChange {
          document: NativeDocumentSnapshot;
          newIndex: number;
          oldIndex: number;
          type: string;
        }

        interface NativeDocumentSnapshot {
          data: {
            [key: string]: TypeMap;
          };
          metadata: SnapshotMetadata;
          path: string;
        }

        interface SnapshotMetadata {
          fromCache: boolean;
          hasPendingWrites: boolean;
        }

        type QueryDirection = 'asc' | 'ASC' | 'desc' | 'DESC';
        type QueryOperator = '=' | '==' | '>' | '>=' | '<' | '<=';

        interface TypeMap {
          type:
            | 'array'
            | 'boolean'
            | 'date'
            | 'documentid'
            | 'fieldvalue'
            | 'geopoint'
            | 'null'
            | 'number'
            | 'object'
            | 'reference'
            | 'string';
          value: any;
        }

        /** The key in update() function for DocumentReference and WriteBatch. */
        type UpdateKey = string | FieldPath;

        interface WriteOptions {
          merge?: boolean;
        }
      }
    }
  }
}