@react-native-firebase/firestore 23.8.6 → 24.0.0

package/dist/typescript/lib/types/namespaced.d.ts

@@ -0,0 +1,2285 @@
+import { ReactNativeFirebase } from '@react-native-firebase/app';
+/**
+ * Firebase Cloud Firestore package for React Native.
+ *
+ * #### Example: Access the firebase export from the `firestore` package:
+ *
+ * ```js
+ * import { firebase } from '@react-native-firebase/firestore';
+ *
+ * // firebase.firestore().X
+ * ```
+ *
+ * #### Example: Using the default export from the `firestore` package:
+ *
+ * ```js
+ * import firestore from '@react-native-firebase/firestore';
+ *
+ * // firestore().X
+ * ```
+ *
+ * #### Example: Using the default export from the `app` package:
+ *
+ * ```js
+ * import firebase from '@react-native-firebase/app';
+ * import '@react-native-firebase/firestore';
+ *
+ * // firebase.firestore().X
+ * ```
+ *
+ * @firebase firestore
+ */
+export declare namespace FirebaseFirestoreTypes {
+    type _FirebaseModule = ReactNativeFirebase.FirebaseModule;
+    /**
+     * An instance of Filter used to generate Firestore Filter queries.
+     */
+    export type QueryFilterType = 'OR' | 'AND';
+    export interface QueryFieldFilterConstraint<T extends DocumentData = DocumentData> {
+        fieldPath: keyof T | FieldPath;
+        operator: WhereFilterOp;
+        value: any;
+    }
+    export interface QueryCompositeFilterConstraint<T extends DocumentData = DocumentData> {
+        operator: QueryFilterType;
+        queries: QueryFieldFilterConstraint<T>[];
+    }
+    export type QueryFilterConstraint<T extends DocumentData = DocumentData> = QueryFieldFilterConstraint<T> | QueryCompositeFilterConstraint<T>;
+    /**
+     * The Filter functions used to generate an instance of Filter.
+     */
+    export interface FilterFunction<T extends DocumentData = DocumentData> {
+        /**
+         * The Filter function used to generate an instance of Filter.
+         * e.g. Filter('name', '==', 'Ada')
+         */
+        (fieldPath: keyof T | FieldPath, operator: WhereFilterOp, value: any): QueryFieldFilterConstraint<T>;
+        /**
+         * The Filter.or() static function used to generate a logical OR query using multiple Filter instances.
+         * e.g. Filter.or(Filter('name', '==', 'Ada'), Filter('name', '==', 'Bob'))
+         */
+        or(...queries: QueryFilterConstraint<T>[]): QueryCompositeFilterConstraint<T>;
+        /**
+         * The Filter.and() static function used to generate a logical AND query using multiple Filter instances.
+         * e.g. Filter.and(Filter('name', '==', 'Ada'), Filter('name', '==', 'Bob'))
+         */
+        and(...queries: QueryFilterConstraint<T>[]): QueryCompositeFilterConstraint<T>;
+    }
+    /**
+     * The Filter function used to generate an instance of Filter.
+     * e.g. Filter('name', '==', 'Ada')
+     */
+    export const Filter: FilterFunction;
+    /**
+     * An immutable object representing an array of bytes.
+     */
+    export class Blob {
+        /**
+         * Creates a new Blob from the given Base64 string, converting it to bytes.
+         *
+         * @param base64 The Base64 string used to create the Blob object.
+         */
+        static fromBase64String(base64: string): Blob;
+        /**
+         * Creates a new Blob from the given Uint8Array.
+         *
+         * @param array The Uint8Array used to create the Blob object.
+         */
+        static fromUint8Array(array: Uint8Array): Blob;
+        /**
+         * Returns true if this `Blob` is equal to the provided one.
+         *
+         * @param other The `Blob` to compare against.
+         */
+        isEqual(other: Blob): boolean;
+        /**
+         * Returns the bytes of a Blob as a Base64-encoded string.
+         */
+        toBase64(): string;
+        /**
+         * Returns the bytes of a Blob in a new Uint8Array.
+         */
+        toUint8Array(): Uint8Array;
+    }
+    /**
+     * A `DocumentData` object represents the data in a document.
+     */
+    export interface DocumentData {
+        [key: string]: any;
+    }
+    /**
+     * A `CollectionReference` object can be used for adding documents, getting document references, and querying for
+     * documents (using the methods inherited from `Query`).
+     */
+    export class CollectionReference<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> extends Query<AppModelType, DbModelType> {
+        /**
+         * The collection's identifier.
+         */
+        id: string;
+        /**
+         * A reference to the containing `DocumentReference` if this is a subcollection. If this isn't a
+         * subcollection, the reference is null.
+         */
+        parent: DocumentReference<DocumentData, DocumentData> | null;
+        /**
+         * A string representing the path of the referenced collection (relative to the root of the database).
+         */
+        path: string;
+        /**
+         * Add a new document to this collection with the specified data, assigning it a document ID automatically.
+         *
+         * #### Example
+         *
+         * ```js
+         * const documentRef = await firebase.firestore().collection('users').add({
+         *   name: 'Ada Lovelace',
+         *   age: 30,
+         * });
+         * ```
+         *
+         * @param data An Object containing the data for the new document.
+         */
+        add(data: AppModelType): Promise<DocumentReference<AppModelType, DbModelType>>;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * await firebase.firestore().collection('users').doc('alovelace').set({
+         *   name: 'Ada Lovelace',
+         *   age: 30,
+         * });
+         * ```
+         *
+         * @param documentPath A slash-separated path to a document.
+         */
+        doc(documentPath?: string): DocumentReference<AppModelType, DbModelType>;
+        /**
+         * 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.
+         *
+         * @param converter Converts objects to and from Firestore. Passing in
+         * `null` removes the current converter.
+         * @return A CollectionReference<U> that uses the provided converter.
+         */
+        withConverter(converter: null): CollectionReference<DocumentData, DocumentData>;
+        /**
+         * 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.
+         *
+         * @param converter Converts objects to and from Firestore. Passing in
+         * `null` removes the current converter.
+         * @return A CollectionReference<U> that uses the provided converter.
+         */
+        withConverter<NewAppModelType extends DocumentData, NewDbModelType extends DocumentData = DocumentData>(converter: FirestoreDataConverter<NewAppModelType, NewDbModelType>): CollectionReference<NewAppModelType, NewDbModelType>;
+    }
+    /**
+     * A DocumentChange represents a change to the documents matching a query. It contains the document affected and the
+     * type of change that occurred.
+     */
+    export interface DocumentChange<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> {
+        /**
+         * The document affected by this change.
+         */
+        doc: QueryDocumentSnapshot<AppModelType, DbModelType>;
+        /**
+         * 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.
+         */
+        newIndex: 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.
+         */
+        oldIndex: number;
+        /**
+         * The type of change ('added', 'modified', or 'removed').
+         */
+        type: DocumentChangeType;
+    }
+    /**
+     * The type of a DocumentChange may be 'added', 'removed', or 'modified'.
+     */
+    export type DocumentChangeType = 'added' | 'removed' | 'modified';
+    /**
+     * An options object that configures how document snapshot data is returned (e.g. server timestamps).
+     */
+    export type SnapshotOptions = {
+        readonly serverTimestamps?: 'estimate' | 'previous' | 'none';
+    };
+    /**
+     * The types for a DocumentSnapshot field that are supported by Firestore.
+     */
+    export type DocumentFieldType = string | number | boolean | {
+        [key: string]: DocumentFieldType;
+    } | DocumentFieldType[] | null | Timestamp | GeoPoint | Blob | FieldPath | FieldValue | DocumentReference<DocumentData, DocumentData> | CollectionReference<DocumentData, 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.
+     */
+    export class DocumentReference<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> {
+        /**
+         * The Firestore instance the document is in. This is useful for performing transactions, for example.
+         */
+        firestore: Module;
+        /**
+         * The document's identifier within its collection.
+         */
+        id: string;
+        /**
+         * The Collection this `DocumentReference` belongs to.
+         */
+        parent: CollectionReference<AppModelType, DbModelType>;
+        /**
+         * A string representing the path of the referenced document (relative to the root of the database).
+         */
+        path: string;
+        /**
+         * Gets a `CollectionReference` instance that refers to the collection at the specified path.
+         *
+         * #### Example
+         *
+         * ```js
+         * const collectionRef = firebase.firestore().doc('users/alovelace').collection('orders');
+         * ```
+         *
+         * @param collectionPath A slash-separated path to a collection.
+         */
+        collection(collectionPath: string): CollectionReference<DocumentData, DocumentData>;
+        /**
+         * Deletes the document referred to by this DocumentReference.
+         *
+         * #### Example
+         *
+         * ```js
+         * await firebase.firestore().doc('users/alovelace').delete();
+         * ```
+         *
+         * The Promise is resolved once the document has been successfully deleted from the backend
+         * (Note that it won't resolve while you're offline).
+         */
+        delete(): Promise<void>;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * await firebase.firestore().doc('users/alovelace').get({
+         *   source: 'server',
+         * });
+         * ```
+         *
+         * @param options An object to configure the get behavior.
+         */
+        get(options?: GetOptions): Promise<DocumentSnapshot<AppModelType, DbModelType>>;
+        /**
+         * Returns true if this DocumentReference is equal to the provided one.
+         *
+         * #### Example
+         *
+         * ```js
+         * const alovelace = firebase.firestore().doc('users/alovelace');
+         * const dsmith = firebase.firestore().doc('users/dsmith');
+         *
+         * // false
+         * alovelace.isEqual(dsmith);
+         * ```
+         *
+         * @param other The `DocumentReference` to compare against.
+         */
+        isEqual(other: DocumentReference<AppModelType, DbModelType>): boolean;
+        /**
+         * Attaches a listener for DocumentSnapshot events.
+         *
+         * NOTE: Although an complete callback can be provided, it will never be called because the snapshot stream is never-ending.
+         *
+         * Returns an unsubscribe function to stop listening to events.
+         *
+         * #### Example
+         *
+         * ```js
+         * const unsubscribe = firebase.firestore().doc('users/alovelace')
+         *   .onSnapshot({
+         *     error: (e) => console.error(e),
+         *     next: (documentSnapshot) => {},
+         *   });
+         *
+         * unsubscribe();
+         * ```
+         *
+         * @param observer A single object containing `next` and `error` callbacks.
+         */
+        onSnapshot(observer: {
+            complete?: () => void;
+            error?: (error: Error) => void;
+            next?: (snapshot: DocumentSnapshot<AppModelType, DbModelType>) => void;
+        }): () => void;
+        /**
+         * Attaches a listener for DocumentSnapshot events with snapshot listener options.
+         *
+         * NOTE: Although an complete callback can be provided, it will never be called because the snapshot stream is never-ending.
+         *
+         * Returns an unsubscribe function to stop listening to events.
+         *
+         * #### Example
+         *
+         * ```js
+         * const unsubscribe = firebase.firestore().doc('users/alovelace')
+         *   .onSnapshot({
+         *     includeMetadataChanges: true,
+         *   }, {
+         *     error: (e) => console.error(e),
+         *     next: (documentSnapshot) => {},
+         *   });
+         *
+         * unsubscribe();
+         * ```
+         *
+         * @param options Options controlling the listen behavior.
+         * @param observer A single object containing `next` and `error` callbacks.
+         */
+        onSnapshot(options: SnapshotListenOptions, observer: {
+            complete?: () => void;
+            error?: (error: Error) => void;
+            next?: (snapshot: DocumentSnapshot<AppModelType, DbModelType>) => void;
+        }): () => void;
+        /**
+         * Attaches a listener for DocumentSnapshot events.
+         *
+         * NOTE: Although an onCompletion callback can be provided, it will never be called because the snapshot stream is never-ending.
+         *
+         * Returns an unsubscribe function to stop listening to events.
+         *
+         * #### Example
+         *
+         * ```js
+         * const unsubscribe = firebase.firestore().doc('users/alovelace')
+         *   .onSnapshot(
+         *     (documentSnapshot) => {}, // onNext
+         *     (error) => console.error(error), // onError
+         *   );
+         *
+         * unsubscribe();
+         * ```
+         * @param onNext A callback to be called every time a new `DocumentSnapshot` is available.
+         * @param onError A callback to be called if the listen fails or is cancelled. No further callbacks will occur.
+         * @param onCompletion An optional function which will never be called.
+         */
+        onSnapshot(onNext: (snapshot: DocumentSnapshot<AppModelType, DbModelType>) => void, onError?: (error: Error) => void, onCompletion?: () => void): () => void;
+        /**
+         * Attaches a listener for DocumentSnapshot events with snapshot listener options.
+         *
+         * NOTE: Although an onCompletion callback can be provided, it will never be called because the snapshot stream is never-ending.
+         *
+         * Returns an unsubscribe function to stop listening to events.
+         *
+         * #### Example
+         *
+         * ```js
+         * const unsubscribe = firebase.firestore().doc('users/alovelace')
+         *   .onSnapshot(
+         *     { includeMetadataChanges: true }, // SnapshotListenerOptions
+         *     (documentSnapshot) => {}, // onNext
+         *     (error) => console.error(error), // onError
+         *   );
+         *
+         * unsubscribe();
+         * ```
+         * @param options Options controlling the listen behavior.
+         * @param onNext A callback to be called every time a new `DocumentSnapshot` is available.
+         * @param onError A callback to be called if the listen fails or is cancelled. No further callbacks will occur.
+         * @param onCompletion An optional function which will never be called.
+         */
+        onSnapshot(options: SnapshotListenOptions, onNext: (snapshot: DocumentSnapshot<AppModelType, DbModelType>) => void, onError?: (error: Error) => void, onCompletion?: () => void): () => 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const user = firebase.firestore().doc('users/alovelace');
+         *
+         * // Set new data
+         * await user.set({
+         *   name: 'Ada Lovelace',
+         *   age: 30,
+         *   city: 'LON',
+         * });
+         * ```
+         *
+         * @param data A map of the fields and values for the document.
+         * @param options An object to configure the set behavior.
+         */
+        set(data: SetValue<AppModelType>, options?: SetOptions): 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.
+         *
+         * #### Example
+         *
+         * ```
+         * const user = firebase.firestore().doc('users/alovelace');
+         *
+         * // Update age but leave other fields untouched
+         * await user.update({
+         *   age: 31,
+         * });
+         * ```
+         *
+         * @param 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.
+         */
+        update(data: Partial<SetValue<DbModelType>>): 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.
+         *
+         * #### Example
+         *
+         * ```
+         * const user = firebase.firestore().doc('users/alovelace');
+         *
+         * // Update age & city but leve other fields untouched
+         * await user.update('age', 31, 'city', 'SF');
+         * ```
+         *
+         * @param field The first field to update.
+         * @param value The first value.
+         * @param moreFieldsAndValues Additional key value pairs.
+         */
+        update(field: keyof DbModelType | FieldPath, value: any, ...moreFieldsAndValues: any[]): Promise<void>;
+        /**
+         * Removes the current converter.
+         *
+         * @param converter Passing in `null` removes the current converter.
+         * @return A DocumentReference<U> that uses the provided converter.
+         */
+        withConverter(converter: null): DocumentReference<DocumentData, DocumentData>;
+        /**
+         * Applies a custom data converter to this `DocumentReference`, allowing you
+         * to use your own custom model objects with Firestore. When you call setDoc
+         * getDoc, etc. with the returned `DocumentReference`
+         * instance, the provided converter will convert between Firestore data of
+         * type `NewDbModelType` and your custom type `NewAppModelType`.
+         *
+         * @param converter - Converts objects to and from Firestore.
+         * @returns A `DocumentReference` that uses the provided converter.
+         */
+        withConverter<NewAppModelType extends DocumentData, NewDbModelType extends DocumentData = DocumentData>(converter: FirestoreDataConverter<NewAppModelType, NewDbModelType>): DocumentReference<NewAppModelType, NewDbModelType>;
+    }
+    /**
+     * 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()` method to explicitly verify a document's existence.
+     */
+    export interface DocumentSnapshot<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> {
+        /**
+         * Method of the `DocumentSnapshot` that signals whether or not the data exists. True if the document exists.
+         */
+        exists(): boolean;
+        /**
+         * Property of the `DocumentSnapshot` that provides the document's ID.
+         */
+        id: string;
+        /**
+         * Metadata about the `DocumentSnapshot`, including information about its source and local modifications.
+         */
+        metadata: SnapshotMetadata;
+        /**
+         * The `DocumentReference` for the document included in the `DocumentSnapshot`.
+         */
+        ref: DocumentReference<AppModelType, DbModelType>;
+        /**
+         * Retrieves all fields in the document as an Object. Returns 'undefined' if the document doesn't exist.
+         *
+         * #### Example
+         *
+         * ```js
+         * const user = await firebase.firestore().doc('users/alovelace').get();
+         *
+         * console.log('User', user.data());
+         * ```
+         */
+        data(): AppModelType | undefined;
+        /**
+         * Retrieves the field specified by fieldPath. Returns undefined if the document or field doesn't exist.
+         *
+         * #### Example
+         *
+         * ```js
+         * const user = await firebase.firestore().doc('users/alovelace').get();
+         *
+         * console.log('Address ZIP Code', user.get('address.zip'));
+         * ```
+         *
+         * @param fieldPath The path (e.g. 'foo' or 'foo.bar') to a specific field.
+         */
+        get<fieldType extends DocumentFieldType>(fieldPath: keyof AppModelType | string | FieldPath): fieldType;
+        /**
+         * Returns true if this `DocumentSnapshot` is equal to the provided one.
+         *
+         * #### Example
+         *
+         * ```js
+         * const user1 = await firebase.firestore().doc('users/alovelace').get();
+         * const user2 = await firebase.firestore().doc('users/dsmith').get();
+         *
+         * // false
+         * user1.isEqual(user2);
+         * ```
+         *
+         * @param other The `DocumentSnapshot` to compare against.
+         */
+        isEqual(other: DocumentSnapshot<AppModelType, DbModelType>): boolean;
+    }
+    /**
+     * 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() method will always be true and data() will never return 'undefined'.
+     */
+    export interface QueryDocumentSnapshot<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> extends DocumentSnapshot<AppModelType, DbModelType> {
+        /**
+         * A QueryDocumentSnapshot is always guaranteed to exist.
+         */
+        exists(): true;
+        /**
+         * Retrieves all fields in the document as an Object.
+         *
+         * #### Example
+         *
+         * ```js
+         * const users = await firebase.firestore().collection('users').get();
+         *
+         * for (const user of users.docs) {
+         *   console.log('User', user.data());
+         * }
+         * ```
+         */
+        data(): AppModelType;
+    }
+    /**
+     * 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.
+     *
+     * #### Example
+     *
+     * ```js
+     * const user = await firebase.firestore().doc('users/alovelace').get();
+     *
+     * // Create a new field path
+     * const fieldPath = new firebase.firestore.FieldPath('address', 'zip');
+     *
+     * console.log('Address ZIP Code', user.get(fieldPath));
+     * ```
+     */
+    export class 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.
+         */
+        static documentId(): FieldPath;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const fieldPath = new firebase.firestore.FieldPath('address', line', 'one');
+         * ```
+         *
+         * @param fieldNames A list of field names.
+         */
+        constructor(...fieldNames: string[]);
+        /**
+         * Returns true if this `FieldPath` is equal to the provided one.
+         *
+         * #### Example
+         *
+         * ```js
+         * const fieldPath1 = new firebase.firestore.FieldPath('address', 'zip');
+         * const fieldPath2 = new firebase.firestore.FieldPath('address', line', 'one');
+         *
+         * // false
+         * fieldPath1.isEqual(fieldPath2);
+         * ```
+         *
+         * @param other The `FieldPath` to compare against.
+         */
+        isEqual(other: FieldPath): boolean;
+    }
+    /**
+     * Sentinel values that can be used when writing document fields with `set()` or `update()`.
+     *
+     * #### Example
+     *
+     * ```js
+     * const increment = firebase.firestore.FieldValue.increment(1);
+     *
+     * await firebase.firestore().doc('users/alovelace').update({
+     *   age: increment, // increment age by 1
+     * });
+     * ```
+     */
+    export class 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const arrayRemove = firebase.firestore.FieldValue.arrayRemove(2, '3');
+         *
+         * // Removes the values 2 & '3' from the values array on the document
+         * await docRef.update({
+         *   values: arrayRemove,
+         * });
+         * ```
+         *
+         * @param elements The elements to remove from the array.
+         */
+        static arrayRemove(...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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const arrayUnion = firebase.firestore.FieldValue.arrayUnion(2, '3');
+         *
+         * // Appends the values 2 & '3' onto the values array on the document
+         * await docRef.update({
+         *   values: arrayUnion,
+         * });
+         * ```
+         *
+         * @param elements The elements to union into the array.
+         */
+        static arrayUnion(...elements: any[]): FieldValue;
+        /**
+         * Returns a sentinel for use with update() to mark a field for deletion.
+         *
+         * #### Example
+         *
+         * ```js
+         * const delete = firebase.firestore.FieldValue.delete();
+         *
+         * // Deletes the name field on the document
+         * await docRef.update({
+         *   name: delete,
+         * });
+         * ```
+         */
+        static delete(): 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const increment = firebase.firestore.FieldValue.increment(1);
+         *
+         * // Increment the loginCount field by 1 on the document
+         * await docRef.update({
+         *   loginCount: increment,
+         * });
+         * ```
+         *
+         * Please be careful using this operator. It may not be reliable enough for use in circumstances where absolute accuracy is required,
+         * as it appears writes to Firestore may sometimes be duplicated in situations not fully understood yet, but possibly correlated with
+         * write frequency. See https://github.com/invertase/react-native-firebase/discussions/5914
+         *
+         * @param n The value to increment by.
+         */
+        static increment(n: number): FieldValue;
+        /**
+         * Returns a sentinel used with set() or update() to include a server-generated timestamp in the written data.
+         *
+         * #### Example
+         *
+         * ```js
+         * const timestamp = firebase.firestore.FieldValue.serverTimestamp();
+         *
+         * // Set the updatedAt field to the current server time
+         * await docRef.update({
+         *   updatedAt: timestamp,
+         * });
+         * ```
+         */
+        static serverTimestamp(): FieldValue;
+        /**
+         * Returns true if this `FieldValue` is equal to the provided one.
+         *
+         * #### Example
+         *
+         * ```js
+         * const increment = firebase.firestore.FieldValue.increment(1);
+         * const timestamp = firebase.firestore.FieldValue.serverTimestamp();
+         *
+         * // false
+         * increment.isEqual(timestamp);
+         * ```
+         *
+         * @param other The `FieldValue` to compare against.
+         */
+        isEqual(other: FieldValue): boolean;
+    }
+    /**
+     * 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].
+     */
+    export class GeoPoint {
+        /**
+         * Creates a new immutable GeoPoint object with the provided latitude and longitude values.
+         *
+         * #### Example
+         *
+         * ```js
+         * const geoPoint = new firebase.firestore.GeoPoint(60, -40);
+         * ```
+         *
+         * @param latitude The latitude as number between -90 and 90.
+         * @param longitude The longitude as number between -180 and 180.
+         */
+        constructor(latitude: number, longitude: number);
+        /**
+         * The latitude of this `GeoPoint` instance.
+         */
+        latitude: number;
+        /**
+         * The longitude of this `GeoPoint` instance.
+         */
+        longitude: number;
+        /**
+         * Returns true if this `GeoPoint` is equal to the provided one.
+         *
+         * #### Example
+         *
+         * ```js
+         * const geoPoint1 = new firebase.firestore.GeoPoint(60, -40);
+         * const geoPoint2 = new firebase.firestore.GeoPoint(60, -20);
+         *
+         * // false
+         * geoPoint1.isEqual(geoPoint2);
+         * ```
+         *
+         * @param other The `GeoPoint` to compare against.
+         */
+        isEqual(other: GeoPoint): boolean;
+        /**
+         * Returns a JSON-serializable representation of this GeoPoint.
+         */
+        toJSON(): {
+            latitude: number;
+            longitude: number;
+        };
+    }
+    /**
+     * 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).
+     */
+    export interface GetOptions {
+        /**
+         * 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.
+         */
+        source: 'default' | 'server' | 'cache';
+    }
+    /**
+     * Represents an aggregation that can be performed by Firestore.
+     */
+    export class AggregateField<_T> {
+        /** A type string to uniquely identify instances of this class. */
+        type: string;
+    }
+    /**
+     * The union of all `AggregateField` types that are supported by Firestore.
+     */
+    export type AggregateFieldType = AggregateField<number>;
+    /**
+     * A type whose property values are all `AggregateField` objects.
+     */
+    export interface AggregateSpec {
+        [field: string]: AggregateFieldType;
+    }
+    /**
+     * A type whose keys are taken from an `AggregateSpec`, and whose values are the
+     * result of the aggregation performed by the corresponding `AggregateField`
+     * from the input `AggregateSpec`.
+     */
+    export type AggregateSpecData<T extends AggregateSpec> = {
+        [P in keyof T]: T[P] extends AggregateField<infer U> ? U : never;
+    };
+    /**
+     * The results of executing an aggregation query.
+     */
+    export interface AggregateQuerySnapshot<AggregateSpecType extends AggregateSpec, AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> {
+        /**
+         * The underlying query over which the aggregations recorded in this
+         * `AggregateQuerySnapshot` were performed.
+         */
+        get query(): Query<AppModelType, DbModelType>;
+        /**
+         * Returns the results of the aggregations performed over the underlying
+         * query.
+         *
+         * The keys of the returned object will be the same as those of the
+         * `AggregateSpec` object specified to the aggregation method, and the values
+         * will be the corresponding aggregation result.
+         *
+         * @returns The results of the aggregations performed over the underlying
+         * query.
+         */
+        data(): AggregateSpecData<AggregateSpecType>;
+    }
+    /**
+     * The results of requesting an aggregated query.
+     */
+    export interface AggregateQuery<T extends AggregateSpec> {
+        /**
+         * The underlying query for this instance.
+         */
+        get query(): Query<DocumentData, DocumentData>;
+        /**
+         * Executes the query and returns the results as a AggregateQuerySnapshot.
+         *
+         *
+         * #### Example
+         *
+         * ```js
+         * const querySnapshot = await firebase.firestore()
+         *   .collection('users')
+         *   .count()
+         *   .get();
+         * ```
+         *
+         * @param options An object to configure the get behavior.
+         */
+        get(): Promise<AggregateQuerySnapshot<T>>;
+    }
+    /**
+     * 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.
+     */
+    export class Query<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> {
+        /**
+         * Calculates the number of documents in the result set of the given query, without actually downloading
+         * the documents.
+         *
+         * Using this function to count the documents is efficient because only the final count, not the
+         * documents' data, is downloaded. This function can even count the documents if the result set
+         * would be prohibitively large to download entirely (e.g. thousands of documents).
+         *
+         * The result received from the server is presented, unaltered, without considering any local state.
+         * That is, documents in the local cache are not taken into consideration, neither are local
+         * modifications not yet synchronized with the server. Previously-downloaded results, if any,
+         *  are not used: every request using this source necessarily involves a round trip to the server.
+         */
+        count(): AggregateQuery<{
+            count: AggregateField<number>;
+        }>;
+        /**
+         * Same as count()
+         */
+        countFromServer(): AggregateQuery<{
+            count: AggregateField<number>;
+        }>;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const user = await firebase.firestore().doc('users/alovelace').get();
+         *
+         * // Get all users up to a specific user in order of age
+         * const querySnapshot = await firebase.firestore()
+         *   .collection('users')
+         *   .orderBy('age')
+         *   .endAt(user);
+         * ```
+         *
+         * > Cursor snapshot queries have limitations. Please see [Query limitations](/query-limitations) for more information.
+         *
+         * @param snapshot The snapshot of the document to end at.
+         */
+        endAt(snapshot: DocumentSnapshot<AppModelType, DbModelType>): Query<AppModelType, DbModelType>;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * // Get all users who's age is 30 or less
+         * const querySnapshot = await firebase.firestore()
+         *   .collection('users')
+         *   .orderBy('age')
+         *   .endAt(30);
+         * ```
+         *
+         * @param fieldValues The field values to end this query at, in order of the query's order by.
+         */
+        endAt(...fieldValues: any[]): Query<AppModelType, DbModelType>;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const user = await firebase.firestore().doc('users/alovelace').get();
+         *
+         * // Get all users up to, but not including, a specific user in order of age
+         * const querySnapshot = await firebase.firestore()
+         *   .collection('users')
+         *   .orderBy('age')
+         *   .endBefore(user);
+         * ```
+         *
+         * > Cursor snapshot queries have limitations. Please see [Query limitations](/query-limitations) for more information.
+         *
+         * @param snapshot The snapshot of the document to end before.
+         */
+        endBefore(snapshot: DocumentSnapshot<AppModelType, DbModelType>): Query<AppModelType, DbModelType>;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * // Get all users who's age is 29 or less
+         * const querySnapshot = await firebase.firestore()
+         *   .collection('users')
+         *   .orderBy('age')
+         *   .endBefore(30);
+         * ```
+         *
+         * @param fieldValues The field values to end this query before, in order of the query's order by.
+         */
+        endBefore(...fieldValues: any[]): Query<AppModelType, DbModelType>;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const querySnapshot = await firebase.firestore()
+         *   .collection('users')
+         *   .orderBy('age')
+         *   .get({
+         *     source: 'server',
+         *   });
+         * ```
+         *
+         * @param options An object to configure the get behavior.
+         */
+        get(options?: GetOptions): Promise<QuerySnapshot<AppModelType, DbModelType>>;
+        /**
+         * Returns true if this Query is equal to the provided one.
+         *
+         * #### Example
+         *
+         * ```js
+         * const query = firebase.firestore()
+         *   .collection('users')
+         *   .orderBy('age');
+         *
+         * // false
+         * query.isEqual(
+         *   firebase.firestore()
+         *     .collection('users')
+         *     .orderBy('name')
+         * );
+         * ```
+         *
+         * @param other The `Query` to compare against.
+         */
+        isEqual(other: Query): boolean;
+        /**
+         * Creates and returns a new Query where the results are limited to the specified number of documents.
+         *
+         * #### Example
+         *
+         * ```js
+         * // Get 10 users in order of age
+         * const querySnapshot = firebase.firestore()
+         *   .collection('users')
+         *   .orderBy('age')
+         *   .limit(10)
+         *   .get();
+         * ```
+         *
+         * @param limit The maximum number of items to return.
+         */
+        limit(limit: number): Query<AppModelType, DbModelType>;
+        /**
+         * Creates and returns a new Query where the results are limited to the specified number of documents
+         * starting from the last document. The order is dependent on the second parameter for the `orderBy`
+         * method. If `desc` is used, the order is reversed. `orderBy` method call is required when calling `limitToLast`.
+         *
+         * #### Example
+         *
+         * ```js
+         * // Get the last 10 users in reverse order of age
+         * const querySnapshot = firebase.firestore()
+         *   .collection('users')
+         *   .orderBy('age', 'desc')
+         *   .limitToLast(10)
+         *   .get();
+         * ```
+         *
+         * @param limitToLast The maximum number of items to return.
+         */
+        limitToLast(limitToLast: number): Query<AppModelType, DbModelType>;
+        /**
+         * Attaches a listener for `QuerySnapshot` events.
+         *
+         * > Although an `onCompletion` callback can be provided, it will never be called because the snapshot stream is never-ending.
+         *
+         * Returns an unsubscribe function to stop listening to events.
+         *
+         * #### Example
+         *
+         * ```js
+         * const unsubscribe = firebase.firestore().collection('users')
+         *   .onSnapshot({
+         *     error: (e) => console.error(e),
+         *     next: (querySnapshot) => {},
+         *   });
+         *
+         * unsubscribe();
+         * ```
+         *
+         * @param observer A single object containing `next` and `error` callbacks.
+         */
+        onSnapshot(observer: {
+            complete?: () => void;
+            error?: (error: Error) => void;
+            next?: (snapshot: QuerySnapshot<AppModelType, DbModelType>) => void;
+        }): () => void;
+        /**
+         * Attaches a listener for `QuerySnapshot` events with snapshot listener options.
+         *
+         * > Although an `onCompletion` callback can be provided, it will never be called because the snapshot stream is never-ending.
+         *
+         * Returns an unsubscribe function to stop listening to events.
+         *
+         * #### Example
+         *
+         * ```js
+         * const unsubscribe = firebase.firestore().collection('users')
+         *   .onSnapshot({
+         *     includeMetadataChanges: true,
+         *   }, {
+         *     error: (e) => console.error(e),
+         *     next: (querySnapshot) => {},
+         *   });
+         *
+         * unsubscribe();
+         * ```
+         *
+         * @param options Options controlling the listen behavior.
+         * @param observer A single object containing `next` and `error` callbacks.
+         */
+        onSnapshot(options: SnapshotListenOptions, observer: {
+            complete?: () => void;
+            error?: (error: Error) => void;
+            next?: (snapshot: QuerySnapshot<AppModelType, DbModelType>) => void;
+        }): () => void;
+        /**
+         * Attaches a listener for `QuerySnapshot` events.
+         *
+         * > Although an `onCompletion` callback can be provided, it will never be called because the snapshot stream is never-ending.
+         *
+         * Returns an unsubscribe function to stop listening to events.
+         *
+         * #### Example
+         *
+         * ```js
+         * const unsubscribe = firebase.firestore().collection('users')
+         *   .onSnapshot(
+         *     (querySnapshot) => {}, // onNext
+         *     (error) => console.error(error), // onError
+         *   );
+         *
+         * unsubscribe();
+         * ```
+         * @param onNext A callback to be called every time a new `QuerySnapshot` is available.
+         * @param onError A callback to be called if the listen fails or is cancelled. No further callbacks will occur.
+         * @param onCompletion An optional function which will never be called.
+         */
+        onSnapshot(onNext: (snapshot: QuerySnapshot<AppModelType, DbModelType>) => void, onError?: (error: Error) => void, onCompletion?: () => void): () => void;
+        /**
+         * Attaches a listener for `QuerySnapshot` events with snapshot listener options.
+         *
+         * NOTE: Although an onCompletion callback can be provided, it will never be called because the snapshot stream is never-ending.
+         *
+         * Returns an unsubscribe function to stop listening to events.
+         *
+         * #### Example
+         *
+         * ```js
+         * const unsubscribe = firebase.firestore().collection('users')
+         *   .onSnapshot(
+         *     { includeMetadataChanges: true }, // SnapshotListenerOptions
+         *     (querySnapshot) => {}, // onNext
+         *     (error) => console.error(error), // onError
+         *   );
+         *
+         * unsubscribe();
+         * ```
+         * @param options Options controlling the listen behavior.
+         * @param onNext A callback to be called every time a new `QuerySnapshot` is available.
+         * @param onError A callback to be called if the listen fails or is cancelled. No further callbacks will occur.
+         * @param onCompletion An optional function which will never be called.
+         */
+        onSnapshot(options: SnapshotListenOptions, onNext: (snapshot: QuerySnapshot<AppModelType, DbModelType>) => void, onError?: (error: Error) => void, onCompletion?: () => void): () => void;
+        /**
+         * Creates and returns a new Query that's additionally sorted by the specified field, optionally in descending order instead of ascending.
+         *
+         * * #### Example
+         *
+         * #### Example
+         *
+         * ```js
+         * // Get users in order of age, descending
+         * const querySnapshot = firebase.firestore()
+         *   .collection('users')
+         *   .orderBy('age', 'desc')
+         *   .get();
+         * ```
+         *
+         * @param fieldPath The field to sort by. Either a string or FieldPath instance.
+         * @param directionStr Optional direction to sort by (`asc` or `desc`). If not specified, order will be ascending.
+         */
+        orderBy(fieldPath: string | FieldPath, directionStr?: 'asc' | 'desc'): Query<AppModelType, DbModelType>;
+        /**
+         * Creates and returns a new Query that starts after the provided document (exclusive). The start
+         * position is relative to the order of the query. The document must contain all of the fields
+         * provided in the orderBy of this query.
+         *
+         * #### Example
+         *
+         * ```js
+         * const user = await firebase.firestore().doc('users/alovelace').get();
+         *
+         * // Get all users up to, but not including, a specific user in order of age
+         * const querySnapshot = await firebase.firestore()
+         *   .collection('users')
+         *   .orderBy('age')
+         *   .startAfter(user)
+         *   .get();
+         * ```
+         *
+         * > Cursor snapshot queries have limitations. Please see [Query limitations](/query-limitations) for more information.
+         *
+         * @param snapshot The snapshot of the document to start after.
+         */
+        startAfter(snapshot: DocumentSnapshot<AppModelType, DbModelType>): Query<AppModelType, DbModelType>;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * // Get all users who's age is above 30
+         * const querySnapshot = await firebase.firestore()
+         *   .collection('users')
+         *   .orderBy('age')
+         *   .startAfter(30)
+         *   .get();
+         * ```
+         *
+         * @param fieldValues The field values to start this query after, in order of the query's order by.
+         */
+        startAfter(...fieldValues: any[]): Query<AppModelType, DbModelType>;
+        /**
+         * Creates and returns a new Query that starts at the provided document (inclusive). The start
+         * position is relative to the order of the query. The document must contain all of the
+         * fields provided in the orderBy of this query.
+         *
+         * #### Example
+         *
+         * ```js
+         * const user = await firebase.firestore().doc('users/alovelace').get();
+         *
+         * // Get all users up to a specific user in order of age
+         * const querySnapshot = await firebase.firestore()
+         *   .collection('users')
+         *   .orderBy('age')
+         *   .startAt(user)
+         *   .get();
+         * ```
+         *
+         * > Cursor snapshot queries have limitations. Please see [Query limitations](/query-limitations) for more information.
+         *
+         * @param snapshot The snapshot of the document to start at.
+         */
+        startAt(snapshot: DocumentSnapshot<AppModelType, DbModelType>): Query<AppModelType, DbModelType>;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * // Get all users who's age is 30 or above
+         * const querySnapshot = await firebase.firestore()
+         *   .collection('users')
+         *   .orderBy('age')
+         *   .startAt(30)
+         *   .get();
+         * ```
+         *
+         * @param fieldValues The field values to start this query at, in order of the query's order by.
+         */
+        startAt(...fieldValues: any[]): Query<AppModelType, DbModelType>;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * // Get all users who's age is 30 or above
+         * const querySnapshot = await firebase.firestore()
+         *   .collection('users')
+         *   .where('age', '>=', 30);
+         *   .get();
+         * ```
+         *
+         * @param fieldPath The path to compare.
+         * @param opStr The operation string (e.g "<", "<=", "==", ">", ">=", "!=", "array-contains", "array-contains-any", "in", "not-in").
+         * @param value The comparison value.
+         */
+        where(fieldPath: string | FieldPath, opStr: WhereFilterOp, value: any): Query<AppModelType, DbModelType>;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * // Get all users who's age is 30 or above
+         * const querySnapshot = await firebase.firestore()
+         *   .collection('users')
+         *   .where(Filter('age', '>=', 30));
+         *   .get();
+         * ```
+         *
+         * @param filter The filter to apply to the query.
+         */
+        where(filter: QueryFilterConstraint): Query<AppModelType, DbModelType>;
+        /**
+         * Removes the current converter.
+         *
+         * @param converter `null` removes the current converter.
+         * @return A Query that uses the provided converter.
+         */
+        withConverter(converter: null): Query<DocumentData, DocumentData>;
+        /**
+         * 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.
+         *
+         * @param converter Converts objects to and from Firestore. Passing in
+         * `null` removes the current converter.
+         * @return A Query<U> that uses the provided converter.
+         */
+        withConverter<NewAppModelType extends DocumentData, NewDbModelType extends DocumentData = DocumentData>(converter: FirestoreDataConverter<NewAppModelType, NewDbModelType>): Query<NewAppModelType, NewDbModelType>;
+    }
+    /**
+     * Filter conditions in a `Query.where()` clause are specified using the strings '<', '<=', '==', '>=', '>', 'array-contains', 'array-contains-any' or 'in'.
+     */
+    export type WhereFilterOp = '<' | '<=' | '==' | '>' | '>=' | '!=' | 'array-contains' | 'array-contains-any' | 'in' | 'not-in';
+    /**
+     * A `QuerySnapshot` contains zero or more `QueryDocumentSnapshot` 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.
+     */
+    export interface QuerySnapshot<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> {
+        /**
+         * An array of all the documents in the `QuerySnapshot`.
+         */
+        docs: Array<QueryDocumentSnapshot<AppModelType, DbModelType>>;
+        /**
+         * True if there are no documents in the `QuerySnapshot`.
+         */
+        empty: boolean;
+        /**
+         * Metadata about this snapshot, concerning its source and if it has local modifications.
+         */
+        metadata: SnapshotMetadata;
+        /**
+         * The query on which you called get or `onSnapshot` in order to `get` this `QuerySnapshot`.
+         */
+        query: Query<AppModelType, DbModelType>;
+        /**
+         * The number of documents in the `QuerySnapshot`.
+         */
+        size: number;
+        /**
+         * 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.
+         *
+         * To include metadata changes, ensure that the `onSnapshot()` method includes metadata changes.
+         *
+         * #### Example
+         *
+         * ```js
+         * firebase.firestore().collection('users')
+         *   .onSnapshot((querySnapshot) => {
+         *     console.log('Metadata Changes', querySnapshot.docChanges());
+         *   });
+         * ```
+         *
+         * #### Example - With metadata changes
+         *
+         * ```js
+         * firebase.firestore().collection('users')
+         *   .onSnapshot({ includeMetadataChanges: true }, (querySnapshot) => {
+         *     console.log('Metadata Changes', querySnapshot.docChanges({
+         *       includeMetadataChanges: true,
+         *     }));
+         *   });
+         * ```
+         *
+         * @param options `SnapshotListenOptions` that control whether metadata-only changes (i.e. only `DocumentSnapshot.metadata` changed) should trigger snapshot events.
+         */
+        docChanges(options?: SnapshotListenOptions): Array<DocumentChange<AppModelType, DbModelType>>;
+        /**
+         * Enumerates all of the documents in the `QuerySnapshot`.
+         *
+         * #### Example
+         *
+         * ```js
+         * const querySnapshot = await firebase.firestore().collection('users').get();
+         *
+         * querySnapshot.forEach((queryDocumentSnapshot) => {
+         *   console.log('User', queryDocumentSnapshot.data());
+         * })
+         * ```
+         *
+         * @param callback A callback to be called with a `QueryDocumentSnapshot` for each document in the snapshot.
+         * @param thisArg The `this` binding for the callback.
+         */
+        forEach(callback: (result: QueryDocumentSnapshot<AppModelType, DbModelType>) => void, thisArg?: unknown): void;
+        /**
+         * Returns true if this `QuerySnapshot` is equal to the provided one.
+         *
+         * #### Example
+         *
+         * ```js
+         * const querySnapshot1 = await firebase.firestore().collection('users').limit(5).get();
+         * const querySnapshot2 = await firebase.firestore().collection('users').limit(10).get();
+         *
+         * // false
+         * querySnapshot1.isEqual(querySnapshot2);
+         * ```
+         *
+         * > This operation can be resource intensive when dealing with large datasets.
+         *
+         * @param other The `QuerySnapshot` to compare against.
+         */
+        isEqual(other: QuerySnapshot): boolean;
+    }
+    /**
+     * An options object that configures the behavior of set() calls in `DocumentReference`, `WriteBatch` and `Transaction`.
+     * 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`.
+     *
+     * Using both `merge` and `mergeFields` together will throw an error.
+     */
+    export interface SetOptions {
+        /**
+         * 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.
+         */
+        merge?: boolean;
+        /**
+         * 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.
+         */
+        mergeFields?: (string | FieldPath)[];
+    }
+    /**
+     * Specifies custom configurations for your Cloud Firestore instance. You must set these before invoking any other methods.
+     *
+     * Used with `firebase.firestore().settings()`.
+     */
+    export interface Settings {
+        /**
+         * Enables or disables local persistent storage.
+         */
+        persistence?: boolean;
+        /**
+         * 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.
+         *
+         * To disable garbage collection and set an unlimited cache size, use `firebase.firestore.CACHE_SIZE_UNLIMITED`.
+         */
+        cacheSizeBytes?: number;
+        /**
+         * The hostname to connect to.
+         *
+         * Note: on android, hosts 'localhost' and '127.0.0.1' are automatically remapped to '10.0.2.2' (the
+         * "host" computer IP address for android emulators) to make the standard development experience easy.
+         * If you want to use the emulator on a real android device, you will need to specify the actual host
+         * computer IP address. Use of this property for emulator connection is deprecated. Use useEmulator instead
+         */
+        host?: string;
+        /**
+         * Whether to use SSL when connecting. A true value is incompatible with the firestore emulator.
+         */
+        ssl?: 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.
+         */
+        ignoreUndefinedProperties?: boolean;
+        /**
+         * 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.
+         *
+         */
+        serverTimestampBehavior?: 'estimate' | 'previous' | 'none';
+    }
+    /**
+     * 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.
+     */
+    export interface SnapshotListenOptions {
+        /**
+         * Include a change even if only the metadata of the query or of a document changed. Default is false.
+         */
+        includeMetadataChanges: boolean;
+    }
+    /**
+     * Metadata about a snapshot, describing the state of the snapshot.
+     */
+    export interface SnapshotMetadata {
+        /**
+         * True if the snapshot includes local writes (`set()` or `update()` calls) that haven't been committed to the backend yet.
+         * If your listener has opted into metadata updates (via `SnapshotListenOptions`) you will receive another snapshot with
+         * `fromCache` equal to false once the client has received up-to-date data from the backend.
+         */
+        fromCache: 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.
+         */
+        hasPendingWrites: boolean;
+        /**
+         * Returns true if this `SnapshotMetadata` is equal to the provided one.
+         *
+         * @param other The `SnapshotMetadata` to compare against.
+         */
+        isEqual(other: SnapshotMetadata): boolean;
+    }
+    /**
+     * 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.
+     */
+    export class Timestamp {
+        /**
+         * Creates a new timestamp from the given JavaScript [Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date).
+         *
+         * @param date The date to initialize the `Timestamp` from.
+         */
+        static fromDate(date: Date): Timestamp;
+        /**
+         * Creates a new timestamp from the given number of milliseconds.
+         *
+         * @param milliseconds Number of milliseconds since Unix epoch 1970-01-01T00:00:00Z.
+         */
+        static fromMillis(milliseconds: number): Timestamp;
+        /**
+         * Creates a new timestamp with the current date, with millisecond precision.
+         */
+        static now(): Timestamp;
+        /**
+         * Creates a new timestamp.
+         *
+         * @param 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.
+         * @param 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.
+         */
+        constructor(seconds: number, nanoseconds: number);
+        /**
+         * The number of nanoseconds of this `Timestamp`;
+         */
+        nanoseconds: number;
+        /**
+         * The number of seconds of this `Timestamp`.
+         */
+        seconds: number;
+        /**
+         * Returns true if this `Timestamp` is equal to the provided one.
+         *
+         * @param other The `Timestamp` to compare against.
+         */
+        isEqual(other: Timestamp): boolean;
+        /**
+         * Convert a Timestamp to a JavaScript Date object. This conversion causes a loss of precision since Date objects
+         * only support millisecond precision.
+         *
+         * Returns a JavaScript [Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) with
+         * millseconds precision.
+         */
+        toDate(): Date;
+        /**
+         * 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.
+         */
+        toMillis(): number;
+        /**
+         * Convert a timestamp to a string in format "FirestoreTimestamp(seconds=`seconds`, nanoseconds=`nanoseconds`)",
+         * with the `seconds` and `nanoseconds` replaced by the values in the Timestamp object
+         */
+        toString(): string;
+        /**
+         * Convert a Timestamp to a JSON object with seconds and nanoseconds members
+         */
+        toJSON(): {
+            seconds: number;
+            nanoseconds: number;
+        };
+        /**
+         * Converts this object to a primitive string, which allows Timestamp objects to be compared
+         * using the `>`, `<=`, `>=` and `>` operators.
+         */
+        valueOf(): string;
+    }
+    /**
+     * 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()`.
+     *
+     * A transaction consists of any number of `get()` operations followed by any number of write operations such as `set()`,
+     * `update()`, or `delete()`. In the case of a concurrent edit, Cloud Firestore runs the entire transaction again. For example,
+     * if a transaction reads documents and another client modifies any of those documents, Cloud Firestore retries the transaction.
+     * This feature ensures that the transaction runs on up-to-date and consistent data.
+     *
+     * Transactions never partially apply writes. All writes execute at the end of a successful transaction.
+     *
+     * When using transactions, note that:
+     *   - Read operations must come before write operations.
+     *   - A function calling a transaction (transaction function) might run more than once if a concurrent edit affects a document that the transaction reads.
+     *   - Transaction functions should not directly modify application state (return a value from the `updateFunction`).
+     *   - Transactions will fail when the client is offline.
+     */
+    export interface Transaction {
+        /**
+         * Deletes the document referred to by the provided `DocumentReference`.
+         *
+         * #### Example
+         *
+         * ```js
+         * const docRef = firebase.firestore().doc('users/alovelace');
+         *
+         * await firebase.firestore().runTransaction((transaction) => {
+         *   return transaction.delete(docRef);
+         * });
+         * ```
+         *
+         * @param documentRef A reference to the document to be deleted.
+         */
+        delete(documentRef: DocumentReference): Transaction;
+        /**
+         * Reads the document referenced by the provided `DocumentReference`.
+         *
+         * #### Example
+         *
+         * ```js
+         * const docRef = firebase.firestore().doc('users/alovelace');
+         *
+         * await firebase.firestore().runTransaction(async (transaction) => {
+         *   const snapshot = await transaction.get(docRef);
+         *    // use snapshot with transaction (see set() or update())
+         *    ...
+         * });
+         * ```
+         *
+         * @param documentRef A reference to the document to be read.
+         */
+        get<T extends DocumentData = DocumentData>(documentRef: DocumentReference<T>): Promise<DocumentSnapshot<T>>;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const docRef = firebase.firestore().doc('users/alovelace');
+         *
+         * await firebase.firestore().runTransaction((transaction) => {
+         *   const snapshot = await transaction.get(docRef);
+         *   const snapshotData = snapshot.data();
+         *
+         *   return transaction.set(docRef, {
+         *     ...data,
+         *     age: 30, // new field
+         *   });
+         * });
+         * ```
+         *
+         * @param documentRef A reference to the document to be set.
+         * @param data An object of the fields and values for the document.
+         * @param options An object to configure the set behavior.
+         */
+        set<T extends DocumentData = DocumentData>(documentRef: DocumentReference<T>, data: T, options?: SetOptions): 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const docRef = firebase.firestore().doc('users/alovelace');
+         *
+         * await firebase.firestore().runTransaction((transaction) => {
+         *   const snapshot = await transaction.get(docRef);
+         *
+         *   return transaction.update(docRef, {
+         *     age: snapshot.data().age + 1,
+         *   });
+         * });
+         * ```
+         *
+         * @param documentRef A reference to the document to be updated.
+         * @param 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.
+         */
+        update<T extends DocumentData = DocumentData>(documentRef: DocumentReference<T>, data: Partial<{
+            [K in keyof T]: T[K] | FieldValue;
+        }>): 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.
+         *
+         * Nested fields can be updated by providing dot-separated field path strings or by providing FieldPath objects.
+         *
+         * #### Example
+         *
+         * ```js
+         * const docRef = firebase.firestore().doc('users/alovelace');
+         *
+         * await firebase.firestore().runTransaction((transaction) => {
+         *   const snapshot = await transaction.get(docRef);
+         *
+         *   return transaction.update(docRef, 'age', snapshot.data().age + 1);
+         * });
+         * ```
+         *
+         * @param documentRef A reference to the document to be updated.
+         * @param field The first field to update.
+         * @param value The first value.
+         * @param moreFieldsAndValues Additional key/value pairs.
+         */
+        update<T extends DocumentData = DocumentData, K extends keyof T = string>(documentRef: DocumentReference<T>, field: K | FieldPath, value: T[K], ...moreFieldsAndValues: any[]): Transaction;
+    }
+    /**
+     * 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.
+     */
+    export interface WriteBatch {
+        /**
+         * Commits all of the writes in this write batch as a single atomic unit.
+         *
+         * Returns 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const batch = firebase.firestore().batch();
+         *
+         * // Perform batch operations...
+         *
+         * await batch.commit();
+         * ```
+         */
+        commit(): Promise<void>;
+        /**
+         * Deletes the document referred to by the provided `DocumentReference`.
+         *
+         * #### Example
+         *
+         * ```js
+         * const batch = firebase.firestore().batch();
+         * const docRef = firebase.firestore().doc('users/alovelace');
+         *
+         * batch.delete(docRef);
+         * ```
+         *
+         * @param documentRef A reference to the document to be deleted.
+         */
+        delete(documentRef: DocumentReference): 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const batch = firebase.firestore().batch();
+         * const docRef = firebase.firestore().doc('users/dsmith');
+         *
+         * batch.set(docRef, {
+         *   name: 'David Smith',
+         *   age: 25,
+         * });
+         * ```
+         *
+         * @param documentRef A reference to the document to be set.
+         * @param data An object of the fields and values for the document.
+         * @param options An object to configure the set behavior.
+         */
+        set<T extends DocumentData = DocumentData>(documentRef: DocumentReference<T>, data: T, options?: SetOptions): 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const batch = firebase.firestore().batch();
+         * const docRef = firebase.firestore().doc('users/alovelace');
+         *
+         * batch.update(docRef, {
+         *   city: 'SF',
+         * });
+         * ```
+         *
+         * @param documentRef A reference to the document to be updated.
+         * @param 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.
+         */
+        update<T extends DocumentData = DocumentData>(documentRef: DocumentReference<T>, data: Partial<{
+            [K in keyof T]: T[K] | FieldValue;
+        }>): WriteBatch;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const batch = firebase.firestore().batch();
+         * const docRef = firebase.firestore().doc('users/alovelace');
+         *
+         * batch.update(docRef, 'city', 'SF', 'age', 31);
+         * ```
+         *
+         * @param documentRef A reference to the document to be updated.
+         * @param field The first field to update.
+         * @param value The first value.
+         * @param moreFieldAndValues Additional key value pairs.
+         */
+        update<T extends DocumentData = DocumentData, K extends keyof T = string>(documentRef: DocumentReference<T>, field: K | FieldPath, value: T[K] | FieldValue, ...moreFieldAndValues: any[]): WriteBatch;
+    }
+    /**
+     * Returns the PersistentCache Index Manager used by the given Firestore object.
+     * The PersistentCacheIndexManager instance, or null if local persistent storage is not in use.
+     */
+    export interface PersistentCacheIndexManager {
+        /**
+         * Enables the SDK to create persistent cache indexes automatically for local query
+         * execution when the SDK believes cache indexes can help improves performance.
+         * This feature is disabled by default.
+         */
+        enableIndexAutoCreation(): Promise<void>;
+        /**
+         * Stops creating persistent cache indexes automatically for local query execution.
+         * The indexes which have been created by calling `enableIndexAutoCreation()` still take effect.
+         */
+        disableIndexAutoCreation(): Promise<void>;
+        /**
+         * Removes all persistent cache indexes. Note this function also deletes indexes
+         * generated by `setIndexConfiguration()`, which is deprecated.
+         */
+        deleteAllIndexes(): Promise<void>;
+    }
+    /**
+     * 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.
+     */
+    export type TaskState = 'Error' | 'Running' | 'Success';
+    /**
+     * Represents a progress update or a final state from loading bundles.
+     */
+    export interface LoadBundleTaskProgress {
+        /**
+         * How many bytes have been loaded.
+         */
+        bytesLoaded: number;
+        /**
+         * How many documents have been loaded.
+         */
+        documentsLoaded: number;
+        /**
+         * Current task state.
+         */
+        taskState: TaskState;
+        /**
+         * How many bytes are in the bundle being loaded.
+         */
+        totalBytes: number;
+        /**
+         * How many documents are in the bundle being loaded.
+         */
+        totalDocuments: number;
+    }
+    /**
+     * `firebase.firestore.X`
+     */
+    export interface Statics {
+        /**
+         * Returns the `Blob` class.
+         */
+        Blob: typeof Blob;
+        /**
+         * Returns the `FieldPath` class.
+         */
+        FieldPath: typeof FieldPath;
+        /**
+         * Returns the `FieldValue` class.
+         */
+        FieldValue: typeof FieldValue;
+        /**
+         * Returns the `GeoPoint` class.
+         */
+        GeoPoint: typeof GeoPoint;
+        /**
+         * Returns the `Timestamp` class.
+         */
+        Timestamp: typeof Timestamp;
+        /**
+         * Returns the `Filter` function.
+         */
+        Filter: typeof Filter;
+        /**
+         * Used to set the cache size to unlimited when passing to `cacheSizeBytes` in
+         * `firebase.firestore().settings()`.
+         */
+        CACHE_SIZE_UNLIMITED: number;
+        /**
+         * Sets the verbosity of Cloud Firestore native device logs (debug, error, or silent).
+         *
+         * - `debug`: the most verbose logging level, primarily for debugging.
+         * - `error`: logs only error events.
+         * - `silent`: turn off logging.
+         *
+         * #### Example
+         *
+         * ```js
+         * firebase.firestore.setLogLevel('silent');
+         * ```
+         *
+         * @param logLevel The verbosity you set for activity and error logging.
+         */
+        setLogLevel(logLevel: 'debug' | 'error' | 'silent'): void;
+        SDK_VERSION: string;
+    }
+    /**
+     * 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
+     * ```typescript
+     * 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
+     * }
+     * ```
+     */
+    export interface FirestoreDataConverter<AppModelType, DbModelType extends DocumentData = 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>`.
+         */
+        toFirestore(modelObject: AppModelType): DocumentData;
+        toFirestore(modelObject: Partial<AppModelType>, options: SetOptions): DocumentData;
+        /**
+         * 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)`.
+         *
+         * @param snapshot A QueryDocumentSnapshot containing your data and metadata.
+         * @param options The SnapshotOptions from the initial call to `data()`.
+         */
+        fromFirestore(snapshot: QueryDocumentSnapshot<DocumentData, DbModelType>, options: SnapshotOptions): AppModelType;
+    }
+    /**
+     * The Firebase Cloud Firestore service is available for the default app or a given app.
+     *
+     * #### Example: Get the firestore instance for the **default app**:
+     *
+     * ```js
+     * const firestoreForDefaultApp = firebase.firestore();
+     * ```
+     *
+     * #### Example: Get the firestore instance for a **secondary app**:
+     *
+     * ```js
+     * const otherApp = firebase.app('otherApp');
+     * const firestoreForOtherApp = firebase.firestore(otherApp);
+     * ```
+     *
+     */
+    export class Module implements _FirebaseModule {
+        /**
+         * The current `FirebaseApp` instance for this Firebase service.
+         */
+        app: ReactNativeFirebase.FirebaseApp;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const batch = firebase.firestore().batch();
+         * batch.delete(...);
+         * ```
+         */
+        batch(): WriteBatch;
+        /**
+         * Gets a `CollectionReference` instance that refers to the collection at the specified path.
+         *
+         * #### Example
+         *
+         * ```js
+         * const collectionReference = firebase.firestore().collection('users');
+         * ```
+         *
+         * @param collectionPath A slash-separated path to a collection.
+         */
+        collection<T extends DocumentData = DocumentData>(collectionPath: string): CollectionReference<T>;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const collectionGroup = firebase.firestore().collectionGroup('orders');
+         * ```
+         *
+         * @param 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.
+         */
+        collectionGroup<T extends DocumentData = DocumentData>(collectionId: string): Query<T>;
+        /**
+         * Disables network usage for this instance. It can be re-enabled via `enableNetwork()`. 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.
+         *
+         * Returns a promise that is resolved once the network has been disabled.
+         *
+         * #### Example
+         *
+         * ```js
+         * await firebase.firestore().disableNetwork();
+         * ```
+         */
+        disableNetwork(): Promise<void>;
+        /**
+         * Gets a `DocumentReference` instance that refers to the document at the specified path.
+         *
+         * #### Example
+         *
+         * ```js
+         * const documentReference = firebase.firestore().doc('users/alovelace');
+         * ```
+         *
+         * @param documentPath A slash-separated path to a document.
+         */
+        doc<T extends DocumentData = DocumentData>(documentPath: string): DocumentReference<T, T>;
+        /**
+         * Re-enables use of the network for this Firestore instance after a prior call to `disableNetwork()`.
+         *
+         * #### Example
+         *
+         * ```js
+         * await firebase.firestore().enableNetwork();
+         * ```
+         */
+        enableNetwork(): Promise<void>;
+        /**
+         * 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.
+         *
+         * #### Example
+         *
+         * ```js
+         * const cityRef = firebase.firestore().doc('cities/SF');
+         *
+         * await firebase.firestore()
+         *   .runTransaction(async (transaction) => {
+         *     const snapshot = await transaction.get(cityRef);
+         *     await transaction.update(cityRef, {
+         *       population: snapshot.data().population + 1,
+         *     });
+         *   });
+         * ```
+         */
+        runTransaction(updateFunction: (transaction: Transaction) => Promise<any>): Promise<any>;
+        /**
+         * Specifies custom settings to be used to configure the Firestore instance. Must be set before invoking any other methods.
+         *
+         * #### Example
+         *
+         * ```js
+         * const settings = {
+         *   cacheSizeBytes: firebase.firestore.CACHE_SIZE_UNLIMITED,
+         * };
+         *
+         * await firebase.firestore().settings(settings);
+         * ```
+         *
+         * @param settings A `Settings` object.
+         */
+        settings(settings: Settings): Promise<void>;
+        /**
+         * Loads a Firestore bundle into the local cache.
+         *
+         * #### Example
+         *
+         * ```js
+         * const resp = await fetch('/createBundle');
+         * const bundleString = await resp.text();
+         * await firestore().loadBundle(bundleString);
+         * ```
+         */
+        loadBundle(bundle: string): Promise<LoadBundleTaskProgress>;
+        /**
+         * Reads a Firestore Query from local cache, identified by the given name.
+         *
+         * #### Example
+         *
+         * ```js
+         * const query = firestore().namedQuery('latest-stories-query');
+         * const storiesSnap = await query.get({ source: 'cache' });
+         * ```
+         */
+        namedQuery<T extends DocumentData = DocumentData>(name: string): Query<T>;
+        /**
+         * Aimed primarily at clearing up any data cached from running tests. Needs to be executed before any database calls
+         * are made.
+         *
+         * #### Example
+         *
+         *```js
+         * await firebase.firestore().clearPersistence();
+         * ```
+         */
+        clearPersistence(): 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 when the logged-in user changes.
+         *
+         * #### Example
+         *
+         *```js
+         * await firebase.firestore().waitForPendingWrites();
+         * ```
+         */
+        waitForPendingWrites(): Promise<void>;
+        /**
+         * Typically called to ensure a new Firestore instance is initialized before calling
+         * `firebase.firestore().clearPersistence()`.
+         *
+         * #### Example
+         *
+         *```js
+         * await firebase.firestore().terminate();
+         * ```
+         */
+        terminate(): Promise<void>;
+        /**
+         * Modify this Firestore instance to communicate with the Firebase Firestore emulator.
+         * This must be called before any other calls to Firebase Firestore to take effect.
+         * Do not use with production credentials as emulator traffic is not encrypted.
+         *
+         * Note: on android, hosts 'localhost' and '127.0.0.1' are automatically remapped to '10.0.2.2' (the
+         * "host" computer IP address for android emulators) to make the standard development experience easy.
+         * If you want to use the emulator on a real android device, you will need to specify the actual host
+         * computer IP address.
+         *
+         * @param host: emulator host (eg, 'localhost')
+         * @param port: emulator port (eg, 8080)
+         */
+        useEmulator(host: string, port: number): void;
+        /**
+         * Gets the `PersistentCacheIndexManager` instance used by this Cloud Firestore instance.
+         * This is not the same as Cloud Firestore Indexes.
+         * Persistent cache indexes are optional indexes that only exist within the SDK to assist in local query execution.
+         * Returns `null` if local persistent storage is not in use.
+         */
+        persistentCacheIndexManager(): PersistentCacheIndexManager | null;
+    }
+    /**
+     * Utility type to allow FieldValue and to allow Date in place of Timestamp objects.
+     */
+    export type SetValue<T> = T extends Timestamp ? Timestamp | Date : T extends object ? {
+        [P in keyof T]: SetValue<T[P]> | FieldValue;
+    } : T;
+    export {};
+}
+type FirestoreNamespace = ReactNativeFirebase.FirebaseModuleWithStaticsAndApp<FirebaseFirestoreTypes.Module, FirebaseFirestoreTypes.Statics> & {
+    firestore: ReactNativeFirebase.FirebaseModuleWithStaticsAndApp<FirebaseFirestoreTypes.Module, FirebaseFirestoreTypes.Statics>;
+    firebase: ReactNativeFirebase.Module;
+    app(name?: string): ReactNativeFirebase.FirebaseApp;
+};
+declare const defaultExport: FirestoreNamespace;
+export declare const firebase: ReactNativeFirebase.Module & {
+    firestore: typeof defaultExport;
+    app(name?: string): ReactNativeFirebase.FirebaseApp & {
+        firestore(): FirebaseFirestoreTypes.Module;
+    };
+};
+export declare const Filter: FirebaseFirestoreTypes.FilterFunction;
+export default defaultExport;
+/**
+ * Attach namespace to `firebase.` and `FirebaseApp.`.
+ */
+declare module '@react-native-firebase/app' {
+    namespace ReactNativeFirebase {
+        import FirebaseModuleWithStaticsAndApp = ReactNativeFirebase.FirebaseModuleWithStaticsAndApp;
+        interface Module {
+            firestore: FirebaseModuleWithStaticsAndApp<FirebaseFirestoreTypes.Module, FirebaseFirestoreTypes.Statics>;
+        }
+        interface FirebaseApp {
+            firestore(databaseId?: string): FirebaseFirestoreTypes.Module;
+        }
+    }
+}
+//# sourceMappingURL=namespaced.d.ts.map