@glissandoo/lib 1.32.6 → 1.32.8

package/helpers/ts-extras/firestore.d.ts

@@ -1,1759 +0,0 @@
-/*!
- * Copyright 2020 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/// <reference types="node" />
-declare namespace FirebaseFirestoreTypes {
-    /**
-     * Document data (for use with `DocumentReference.set()`) consists of fields
-     * mapped to values.
-     */
-    type DocumentData = {
-        [field: string]: any;
-    };
-    /**
-     * Update data (for use with `DocumentReference.update()`) consists of field
-     * paths (e.g. 'foo' or 'foo.baz') mapped to values. Fields that contain dots
-     * reference nested fields within the document.
-     */
-    type UpdateData = {
-        [fieldPath: string]: any;
-    };
-    /**
-     * Sets or disables the log function for all active Firestore instances.
-     *
-     * @param logger A log function that takes a message (such as `console.log`) or
-     * `null` to turn off logging.
-     */
-    function setLogFunction(logger: ((msg: string) => void) | null): void;
-    /**
-     * 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
-     * class Post {
-     *   constructor(readonly title: string, readonly author: string) {}
-     *
-     *   toString(): string {
-     *     return this.title + ', by ' + this.author;
-     *   }
-     * }
-     *
-     * const postConverter = {
-     *   toFirestore(post: Post): FirebaseFirestore.DocumentData {
-     *     return {title: post.title, author: post.author};
-     *   },
-     *   fromFirestore(
-     *     snapshot: FirebaseFirestore.QueryDocumentSnapshot
-     *   ): Post {
-     *     const data = snapshot.data();
-     *     return new Post(data.title, data.author);
-     *   }
-     * };
-     *
-     * const postSnap = await 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
-     * }
-     */
-    interface FirestoreDataConverter<T> {
-        /**
-         * 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: T): DocumentData;
-        toFirestore(modelObject: Partial<T>, options: SetOptions): DocumentData;
-        /**
-         * Called by the Firestore SDK to convert Firestore data into an object of
-         * type T.
-         */
-        fromFirestore(snapshot: QueryDocumentSnapshot): T;
-    }
-    /**
-     * Settings used to directly configure a `Firestore` instance.
-     */
-    interface Settings {
-        /**
-         * The project ID from the Google Developer's Console, e.g.
-         * 'grape-spaceship-123'. We will also check the environment variable
-         * GCLOUD_PROJECT for your project ID.  Can be omitted in environments that
-         * support {@link https://cloud.google.com/docs/authentication Application
-         * Default Credentials}
-         */
-        projectId?: string;
-        /** The hostname to connect to. */
-        host?: string;
-        /** The port to connect to. */
-        port?: number;
-        /**
-         * Local file containing the Service Account credentials as downloaded from
-         * the Google Developers Console. Can  be omitted in environments that
-         * support {@link https://cloud.google.com/docs/authentication Application
-         * Default Credentials}. To configure Firestore with custom credentials, use
-         * the `credentials` property to provide the `client_email` and
-         * `private_key` of your service account.
-         */
-        keyFilename?: string;
-        /**
-         * The 'client_email' and 'private_key' properties of the service account
-         * to use with your Firestore project. Can be omitted in environments that
-         * support {@link https://cloud.google.com/docs/authentication Application
-         * Default Credentials}. If your credentials are stored in a JSON file, you
-         * can specify a `keyFilename` instead.
-         */
-        credentials?: {
-            client_email?: string;
-            private_key?: string;
-        };
-        /** Whether to use SSL when connecting. */
-        ssl?: boolean;
-        /**
-         * The maximum number of idle GRPC channels to keep. A smaller number of idle
-         * channels reduces memory usage but increases request latency for clients
-         * with fluctuating request rates. If set to 0, shuts down all GRPC channels
-         * when the client becomes idle. Defaults to 1.
-         */
-        maxIdleChannels?: number;
-        /**
-         * Whether to use `BigInt` for integer types when deserializing Firestore
-         * Documents. Regardless of magnitude, all integer values are returned as
-         * `BigInt` to match the precision of the Firestore backend. Floating point
-         * numbers continue to use JavaScript's `number` type.
-         */
-        useBigInt?: 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 `false` or omitted, the SDK throws
-         * an exception when it encounters properties of type `undefined`.
-         */
-        ignoreUndefinedProperties?: boolean;
-        [key: string]: any;
-    }
-    /**
-     * `Firestore` represents a Firestore Database and is the entry point for all
-     * Firestore operations.
-     */
-    class Firestore {
-        /**
-         * @param settings Configuration object. See [Firestore Documentation]
-         * {@link https://firebase.google.com/docs/firestore/}
-         */
-        constructor(settings?: Settings);
-        /**
-         * Specifies custom settings to be used to configure the `Firestore`
-         * instance. Can only be invoked once and before any other Firestore
-         * method.
-         *
-         * If settings are provided via both `settings()` and the `Firestore`
-         * constructor, both settings objects are merged and any settings provided
-         * via `settings()` take precedence.
-         *
-         * @param {object} settings The settings to use for all Firestore
-         * operations.
-         */
-        settings(settings: Settings): void;
-        /**
-         * Gets a `CollectionReference` instance that refers to the collection at
-         * the specified path.
-         *
-         * @param collectionPath A slash-separated path to a collection.
-         * @return The `CollectionReference` instance.
-         */
-        collection(collectionPath: string): CollectionReference<DocumentData>;
-        /**
-         * Gets a `DocumentReference` instance that refers to the document at the
-         * specified path.
-         *
-         * @param documentPath A slash-separated path to a document.
-         * @return The `DocumentReference` instance.
-         */
-        doc(documentPath: string): DocumentReference<DocumentData>;
-        /**
-         * Creates and returns a new Query that includes all documents in the
-         * database that are contained in a collection or subcollection with the
-         * given collectionId.
-         *
-         * @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.
-         * @return The created `CollectionGroup`.
-         */
-        collectionGroup(collectionId: string): CollectionGroup<DocumentData>;
-        /**
-         * Retrieves multiple documents from Firestore.
-         *
-         * The first argument is required and must be of type `DocumentReference`
-         * followed by any additional `DocumentReference` documents. If used, the
-         * optional `ReadOptions` must be the last argument.
-         *
-         * @param {Array.<DocumentReference|ReadOptions>} documentRefsOrReadOptions
-         * The `DocumentReferences` to receive, followed by an optional field
-         * mask.
-         * @return A Promise that resolves with an array of resulting document
-         * snapshots.
-         */
-        getAll(...documentRefsOrReadOptions: Array<DocumentReference<DocumentData> | ReadOptions>): Promise<Array<DocumentSnapshot<DocumentData>>>;
-        /**
-         * Recursively deletes all documents and subcollections at and under the
-         * specified level.
-         *
-         * If any delete fails, the promise is rejected with an error message
-         * containing the number of failed deletes and the stack trace of the last
-         * failed delete. The provided reference is deleted regardless of whether
-         * all deletes succeeded.
-         *
-         * `recursiveDelete()` uses a BulkWriter instance with default settings to
-         * perform the deletes. To customize throttling rates or add success/error
-         * callbacks, pass in a custom BulkWriter instance.
-         *
-         * @param ref The reference of a document or collection to delete.
-         * @param bulkWriter A custom BulkWriter instance used to perform the
-         * deletes.
-         * @return A promise that resolves when all deletes have been performed.
-         * The promise is rejected if any of the deletes fail.
-         *
-         * @example
-         * // Recursively delete a reference and log the references of failures.
-         * const bulkWriter = firestore.bulkWriter();
-         * bulkWriter
-         *   .onWriteError((error) => {
-         *     if (
-         *       error.failedAttempts < MAX_RETRY_ATTEMPTS
-         *     ) {
-         *       return true;
-         *     } else {
-         *       console.log('Failed write at document: ', error.documentRef.path);
-         *       return false;
-         *     }
-         *   });
-         * await firestore.recursiveDelete(docRef, bulkWriter);
-         */
-        recursiveDelete(ref: CollectionReference<unknown> | DocumentReference<unknown>, bulkWriter?: BulkWriter): Promise<void>;
-        /**
-         * Terminates the Firestore client and closes all open streams.
-         *
-         * @return A Promise that resolves when the client is terminated.
-         */
-        terminate(): Promise<void>;
-        /**
-         * Fetches the root collections that are associated with this Firestore
-         * database.
-         *
-         * @returns A Promise that resolves with an array of CollectionReferences.
-         */
-        listCollections(): Promise<Array<CollectionReference<DocumentData>>>;
-        /**
-         * Executes the given updateFunction and commits the changes applied within
-         * the transaction.
-         *
-         * You can use the transaction object passed to 'updateFunction' to read and
-         * modify Firestore documents under lock. Transactions are committed once
-         * 'updateFunction' resolves and attempted up to five times on failure.
-         *
-         * @param updateFunction The function to execute within the transaction
-         * context.
-         * @param {object=} transactionOptions Transaction options.
-         * @param {number=} transactionOptions.maxAttempts The maximum number of
-         * attempts for this transaction.
-         * @return If the transaction completed successfully or was explicitly
-         * aborted (by the updateFunction returning a failed Promise), the Promise
-         * returned by the updateFunction will be returned here. Else if the
-         * transaction failed, a rejected Promise with the corresponding failure
-         * error will be returned.
-         */
-        runTransaction<T>(updateFunction: (transaction: Transaction) => Promise<T>, transactionOptions?: {
-            maxAttempts?: number;
-        }): Promise<T>;
-        /**
-         * Creates a write batch, used for performing multiple writes as a single
-         * atomic operation.
-         */
-        batch(): WriteBatch;
-        /**
-         * Creates a [BulkWriter]{@link BulkWriter}, used for performing
-         * multiple writes in parallel. Gradually ramps up writes as specified
-         * by the 500/50/5 rule.
-         *
-         * @see https://firebase.google.com/docs/firestore/best-practices#ramping_up_traffic
-         *
-         * @param options An options object used to configure the throttling
-         * behavior for the underlying BulkWriter.
-         */
-        bulkWriter(options?: BulkWriterOptions): BulkWriter;
-        /**
-         * Creates a new `BundleBuilder` instance to package selected Firestore data into
-         * a bundle.
-         *
-         * @param bundleId The ID of the bundle. When loaded on clients, client SDKs use this ID
-         * and the timestamp associated with the bundle to tell if it has been loaded already.
-         * If not specified, a random identifier will be used.
-         *
-         *
-         * @example
-         * const bundle = firestore.bundle('data-bundle');
-         * const docSnapshot = await firestore.doc('abc/123').get();
-         * const querySnapshot = await firestore.collection('coll').get();
-         *
-         * const bundleBuffer = bundle.add(docSnapshot); // Add a document
-         *                            .add('coll-query', querySnapshot) // Add a named query.
-         *                            .build()
-         * // Save `bundleBuffer` to CDN or stream it to clients.
-         */
-        bundle(bundleId?: string): BundleBuilder;
-    }
-    /**
-     * 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].
-     */
-    class GeoPoint {
-        /**
-         * Creates a new immutable GeoPoint object with the provided latitude and
-         * longitude values.
-         * @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);
-        readonly latitude: number;
-        readonly longitude: number;
-        /**
-         * Returns true if this `GeoPoint` is equal to the provided one.
-         *
-         * @param other The `GeoPoint` to compare against.
-         * @return true if this `GeoPoint` is equal to the provided one.
-         */
-        isEqual(other: GeoPoint): boolean;
-    }
-    /**
-     * 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()`.
-     */
-    class Transaction {
-        private constructor();
-        /**
-         * Retrieves a query result. Holds a pessimistic lock on all returned
-         * documents.
-         *
-         * @param query A query to execute.
-         * @return A QuerySnapshot for the retrieved data.
-         */
-        get<T>(query: Query<T>): Promise<QuerySnapshot<T>>;
-        /**
-         * Reads the document referenced by the provided `DocumentReference.`
-         * Holds a pessimistic lock on the returned document.
-         *
-         * @param documentRef A reference to the document to be read.
-         * @return A DocumentSnapshot for the read data.
-         */
-        get<T>(documentRef: DocumentReference<T>): Promise<DocumentSnapshot<T>>;
-        /**
-         * Retrieves multiple documents from Firestore. Holds a pessimistic lock on
-         * all returned documents.
-         *
-         * The first argument is required and must be of type `DocumentReference`
-         * followed by any additional `DocumentReference` documents. If used, the
-         * optional `ReadOptions` must be the last argument.
-         *
-         * @param {Array.<DocumentReference|ReadOptions>} documentRefsOrReadOptions
-         * The `DocumentReferences` to receive, followed by an optional field
-         * mask.
-         * @return A Promise that resolves with an array of resulting document
-         * snapshots.
-         */
-        getAll<T>(...documentRefsOrReadOptions: Array<DocumentReference<T> | ReadOptions>): Promise<Array<DocumentSnapshot<T>>>;
-        /**
-         * Create the document referred to by the provided `DocumentReference`.
-         * The operation will fail the transaction if a document exists at the
-         * specified location.
-         *
-         * @param documentRef A reference to the document to be create.
-         * @param data The object data to serialize as the document.
-         * @return This `Transaction` instance. Used for chaining method calls.
-         */
-        create<T>(documentRef: DocumentReference<T>, data: T): Transaction;
-        /**
-         * Writes to the document referred to by the provided `DocumentReference`.
-         * If the document does not exist yet, it will be created. If you pass
-         * `SetOptions`, the provided data can be merged into the existing document.
-         *
-         * @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.
-         * @return This `Transaction` instance. Used for chaining method calls.
-         */
-        set<T>(documentRef: DocumentReference<T>, data: Partial<T>, options: SetOptions): Transaction;
-        set<T>(documentRef: DocumentReference<T>, data: T): 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.
-         *
-         * @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.
-         * @param precondition A Precondition to enforce on this update.
-         * @return This `Transaction` instance. Used for chaining method calls.
-         */
-        update(documentRef: DocumentReference<any>, data: UpdateData, precondition?: Precondition): 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.
-         *
-         * A `Precondition` restricting this update can be specified as the last
-         * argument.
-         *
-         * @param documentRef A reference to the document to be updated.
-         * @param field The first field to update.
-         * @param value The first value
-         * @param fieldsOrPrecondition An alternating list of field paths and values
-         * to update, optionally followed by a `Precondition` to enforce on this
-         * update.
-         * @return This `Transaction` instance. Used for chaining method calls.
-         */
-        update(documentRef: DocumentReference<any>, field: string | FieldPath, value: any, ...fieldsOrPrecondition: any[]): Transaction;
-        /**
-         * Deletes the document referred to by the provided `DocumentReference`.
-         *
-         * @param documentRef A reference to the document to be deleted.
-         * @param precondition A Precondition to enforce for this delete.
-         * @return This `Transaction` instance. Used for chaining method calls.
-         */
-        delete(documentRef: DocumentReference<any>, precondition?: Precondition): Transaction;
-    }
-    /**
-     * A Firestore BulkWriter than can be used to perform a large number of writes
-     * in parallel. Writes to the same document will be executed sequentially.
-     *
-     * @class
-     */
-    class BulkWriter {
-        private constructor();
-        /**
-         * Create a document with the provided data. This single operation will fail
-         * if a document exists at its location.
-         *
-         * @param documentRef A reference to the document to be
-         * created.
-         * @param data The object to serialize as the document.
-         * @returns A promise that resolves with the result of the write. If the
-         * write fails, the promise is rejected with a
-         * [BulkWriterError]{@link BulkWriterError}.
-         */
-        create<T>(documentRef: DocumentReference<T>, data: T): Promise<WriteResult>;
-        /**
-         * Delete a document from the database.
-         *
-         * @param documentRef A reference to the document to be
-         * deleted.
-         * @param precondition A precondition to enforce for this
-         * delete.
-         * @param precondition.lastUpdateTime If set, enforces that the
-         * document was last updated at lastUpdateTime. Fails the batch if the
-         * document doesn't exist or was last updated at a different time.
-         * @param precondition.exists If set, enforces that the target document
-         * must or must not exist.
-         * @returns A promise that resolves with the result of the delete. If the
-         * delete fails, the promise is rejected with a
-         * [BulkWriterError]{@link BulkWriterError}.
-         */
-        delete(documentRef: DocumentReference<any>, precondition?: Precondition): Promise<WriteResult>;
-        /**
-         * Write to the document referred to by the provided
-         * [DocumentReference]{@link DocumentReference}. If the document does not
-         * exist yet, it will be created. If you pass
-         * [SetOptions]{@link SetOptions}., the provided data can be merged into the
-         * existing document.
-         *
-         * @param  documentRef A reference to the document to be
-         * set.
-         * @param data The object to serialize as the document.
-         * @param options An object to configure the set behavior.
-         * @param  options.merge - If true, set() merges the values
-         * specified in its data argument. Fields omitted from this set() call
-         * remain untouched.
-         * @param options.mergeFields - If provided,
-         * set() only replaces the specified field paths. Any field path that is not
-         * specified is ignored and remains untouched.
-         * @returns A promise that resolves with the result of the write. If the
-         * write fails, the promise is rejected with a
-         * [BulkWriterError]{@link BulkWriterError}.
-         */
-        set<T>(documentRef: DocumentReference<T>, data: Partial<T>, options: SetOptions): Promise<WriteResult>;
-        set<T>(documentRef: DocumentReference<T>, data: T): Promise<WriteResult>;
-        /**
-         * Update fields of the document referred to by the provided
-         * [DocumentReference]{@link DocumentReference}. If the document doesn't yet
-         * exist, the update fails and the entire batch will be rejected.
-         *
-         * The update() method accepts either an object with field paths encoded as
-         * keys and field values encoded as values, or a variable number of
-         * arguments that alternate between field paths and field values. Nested
-         * fields can be updated by providing dot-separated field path strings or by
-         * providing FieldPath objects.
-         *
-         *
-         * A Precondition restricting this update can be specified as the last
-         * argument.
-         *
-         * @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.
-         * @param precondition A Precondition to enforce on this update.
-         * @returns A promise that resolves with the result of the write. If the
-         * write fails, the promise is rejected with a
-         * [BulkWriterError]{@link BulkWriterError}.
-         */
-        update(documentRef: DocumentReference<any>, data: UpdateData, precondition?: Precondition): Promise<WriteResult>;
-        /**
-         * Update fields of the document referred to by the provided
-         * [DocumentReference]{@link DocumentReference}. If the document doesn't yet
-         * exist, the update fails and the entire batch will be rejected.
-         *
-         * The update() method accepts either an object with field paths encoded as
-         * keys and field values encoded as values, or a variable number of
-         * arguments that alternate between field paths and field values. Nested
-         * fields can be updated by providing dot-separated field path strings or by
-         * providing FieldPath objects.
-         *
-         *
-         * A Precondition restricting this update can be specified as the last
-         * argument.
-         *
-         * @param documentRef A reference to the document to be updated.
-         * @param field The first field to update.
-         * @param value The first value
-         * @param fieldsOrPrecondition An alternating list of field paths and values
-         * to update, optionally followed a `Precondition` to enforce on this update.
-         * @returns A promise that resolves with the result of the write. If the
-         * write fails, the promise is rejected with a
-         * [BulkWriterError]{@link BulkWriterError}.
-         */
-        update(documentRef: DocumentReference<any>, field: string | FieldPath, value: any, ...fieldsOrPrecondition: any[]): Promise<WriteResult>;
-        /**
-         * Attaches a listener that is run every time a BulkWriter operation
-         * successfully completes.
-         *
-         * @param callback A callback to be called every time a BulkWriter operation
-         * successfully completes.
-         */
-        onWriteResult(callback: (documentRef: DocumentReference<any>, result: WriteResult) => void): void;
-        /**
-         * Attaches an error handler listener that is run every time a BulkWriter
-         * operation fails.
-         *
-         * BulkWriter has a default error handler that retries UNAVAILABLE and
-         * ABORTED errors up to a maximum of 10 failed attempts. When an error
-         * handler is specified, the default error handler will be overwritten.
-         *
-         * @param shouldRetryCallback A callback to be called every time a BulkWriter
-         * operation fails. Returning `true` will retry the operation. Returning
-         * `false` will stop the retry loop.
-         */
-        onWriteError(shouldRetryCallback: (error: BulkWriterError) => boolean): void;
-        /**
-         * Commits all writes that have been enqueued up to this point in parallel.
-         *
-         * Returns a Promise that resolves when all currently queued operations have
-         * been committed. The Promise will never be rejected since the results for
-         * each individual operation are conveyed via their individual Promises.
-         *
-         * The Promise resolves immediately if there are no pending writes.
-         * Otherwise, the Promise waits for all previously issued writes, but it
-         * does not wait for writes that were added after the method is called. If
-         * you want to wait for additional writes, call `flush()` again.
-         *
-         * @return A promise that resolves when all enqueued writes
-         * up to this point have been committed.
-         */
-        flush(): Promise<void>;
-        /**
-         * Commits all enqueued writes and marks the BulkWriter instance as closed.
-         *
-         * After calling `close()`, calling any method will throw an error. Any
-         * retries scheduled as part of an `onWriteError()` handler will be run
-         * before the `close()` promise resolves.
-         *
-         * Returns a Promise that resolves when all writes have been committed. The
-         * Promise will never be rejected. Calling this method will send all
-         * requests. The promise resolves immediately if there are no pending
-         * writes.
-         *
-         * @return A promise that resolves when all enqueued writes
-         * up to this point have been committed.
-         */
-        close(): Promise<void>;
-    }
-    /**
-     * An options object to configure throttling on BulkWriter.
-     */
-    interface BulkWriterOptions {
-        /**
-         * Whether to disable or configure throttling. By default, throttling is
-         * enabled. This field can be set to either a boolean or a config
-         * object. Setting it to `true` will use default values. You can override
-         * the defaults by setting it to `false` to disable throttling, or by
-         * setting the config values to enable throttling with the provided values.
-         *
-         * @see https://firebase.google.com/docs/firestore/best-practices#ramping_up_traffic
-         *
-         * @param initialOpsPerSecond The initial maximum number of operations per
-         * second allowed by the throttler. If this field is not set, the default
-         * is 500 operations per second.
-         * @param maxOpsPerSecond The maximum number of operations per second
-         * allowed by the throttler. If this field is set, the throttler's allowed
-         * operations per second does not ramp up past the specified operations per
-         * second.
-         */
-        readonly throttling?: boolean | {
-            initialOpsPerSecond?: number;
-            maxOpsPerSecond?: number;
-        };
-    }
-    /**
-     * The error thrown when a BulkWriter operation fails.
-     */
-    class BulkWriterError extends Error {
-        /** The status code of the error. */
-        readonly code: GrpcStatus;
-        /** The error message of the error. */
-        readonly message: string;
-        /** The document reference the operation was performed on. */
-        readonly documentRef: DocumentReference<any>;
-        /** The type of operation performed. */
-        readonly operationType: 'create' | 'set' | 'update' | 'delete';
-        /** How many times this operation has been attempted unsuccessfully. */
-        readonly failedAttempts: number;
-    }
-    /**
-     * 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.
-     */
-    class WriteBatch {
-        private constructor();
-        /**
-         * Create the document referred to by the provided `DocumentReference`. The
-         * operation will fail the batch if a document exists at the specified
-         * location.
-         *
-         * @param documentRef A reference to the document to be created.
-         * @param data The object data to serialize as the document.
-         * @return This `WriteBatch` instance. Used for chaining method calls.
-         */
-        create<T>(documentRef: DocumentReference<T>, data: T): WriteBatch;
-        /**
-         * Write 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.
-         *
-         * @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.
-         * @return This `WriteBatch` instance. Used for chaining method calls.
-         */
-        set<T>(documentRef: DocumentReference<T>, data: Partial<T>, options: SetOptions): WriteBatch;
-        set<T>(documentRef: DocumentReference<T>, data: T): WriteBatch;
-        /**
-         * Update fields of the document referred to by the provided
-         * `DocumentReference`. If the document doesn't yet exist, the update fails
-         * and the entire batch will be rejected.
-         *
-         * Nested fields can be updated by providing dot-separated field path
-         * strings.
-         *
-         * @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.
-         * @param precondition A Precondition to enforce on this update.
-         * @return This `WriteBatch` instance. Used for chaining method calls.
-         */
-        update(documentRef: DocumentReference<any>, data: UpdateData, precondition?: Precondition): 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.
-         *
-         * Nested fields can be updated by providing dot-separated field path
-         * strings or by providing FieldPath objects.
-         *
-         * A `Precondition` restricting this update can be specified as the last
-         * argument.
-         *
-         * @param documentRef A reference to the document to be updated.
-         * @param field The first field to update.
-         * @param value The first value
-         * @param fieldsOrPrecondition An alternating list of field paths and values
-         * to update, optionally followed a `Precondition` to enforce on this update.
-         * @return This `WriteBatch` instance. Used for chaining method calls.
-         */
-        update(documentRef: DocumentReference<any>, field: string | FieldPath, value: any, ...fieldsOrPrecondition: any[]): WriteBatch;
-        /**
-         * Deletes the document referred to by the provided `DocumentReference`.
-         *
-         * @param documentRef A reference to the document to be deleted.
-         * @param precondition A Precondition to enforce for this delete.
-         * @return This `WriteBatch` instance. Used for chaining method calls.
-         */
-        delete(documentRef: DocumentReference<any>, precondition?: Precondition): WriteBatch;
-        /**
-         * Commits all of the writes in this write batch as a single atomic unit.
-         *
-         * @return A Promise resolved once all of the writes in the batch have been
-         * successfully written to the backend as an atomic unit.
-         */
-        commit(): Promise<WriteResult[]>;
-    }
-    /**
-     * An options object that configures conditional behavior of `update()` and
-     * `delete()` calls in `DocumentReference`, `WriteBatch`, and `Transaction`.
-     * Using Preconditions, these calls can be restricted to only apply to
-     * documents that match the specified restrictions.
-     */
-    interface Precondition {
-        /**
-         * If set, the last update time to enforce.
-         */
-        readonly lastUpdateTime?: Timestamp;
-        /**
-         * If set, enforces that the target document must or must not exist.
-         */
-        readonly exists?: 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.
-     */
-    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.
-         */
-        readonly 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.
-         *
-         * It is an error to pass a SetOptions object to a set() call that is
-         * missing a value for any of the fields specified here.
-         */
-        readonly mergeFields?: (string | FieldPath)[];
-    }
-    /**
-     * An options object that can be used to configure the behavior of `getAll()`
-     * calls. By providing a `fieldMask`, these calls can be configured to only
-     * return a subset of fields.
-     */
-    interface ReadOptions {
-        /**
-         * Specifies the set of fields to return and reduces the amount of data
-         * transmitted by the backend.
-         *
-         * Adding a field mask does not filter results. Documents do not need to
-         * contain values for all the fields in the mask to be part of the result
-         * set.
-         */
-        readonly fieldMask?: (string | FieldPath)[];
-    }
-    /**
-     * A WriteResult wraps the write time set by the Firestore servers on `sets()`,
-     * `updates()`, and `creates()`.
-     */
-    class WriteResult {
-        private constructor();
-        /**
-         * The write time as set by the Firestore servers.
-         */
-        readonly writeTime: Timestamp;
-        /**
-         * Returns true if this `WriteResult` is equal to the provided one.
-         *
-         * @param other The `WriteResult` to compare against.
-         * @return true if this `WriteResult` is equal to the provided one.
-         */
-        isEqual(other: WriteResult): boolean;
-    }
-    /**
-     * 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.
-     */
-    class DocumentReference<T = DocumentData> {
-        private constructor();
-        /** The identifier of the document within its collection. */
-        readonly id: string;
-        /**
-         * The `Firestore` for the Firestore database (useful for performing
-         * transactions, etc.).
-         */
-        readonly firestore: Firestore;
-        /**
-         * A reference to the Collection to which this DocumentReference belongs.
-         */
-        readonly parent: CollectionReference<T>;
-        /**
-         * A string representing the path of the referenced document (relative
-         * to the root of the database).
-         */
-        readonly path: string;
-        /**
-         * Gets a `CollectionReference` instance that refers to the collection at
-         * the specified path.
-         *
-         * @param collectionPath A slash-separated path to a collection.
-         * @return The `CollectionReference` instance.
-         */
-        collection(collectionPath: string): CollectionReference<DocumentData>;
-        /**
-         * Fetches the subcollections that are direct children of this document.
-         *
-         * @returns A Promise that resolves with an array of CollectionReferences.
-         */
-        listCollections(): Promise<Array<CollectionReference<DocumentData>>>;
-        /**
-         * Creates a document referred to by this `DocumentReference` with the
-         * provided object values. The write fails if the document already exists
-         *
-         * @param data The object data to serialize as the document.
-         * @return A Promise resolved with the write time of this create.
-         */
-        create(data: T): Promise<WriteResult>;
-        /**
-         * 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.
-         *
-         * @param data A map of the fields and values for the document.
-         * @param options An object to configure the set behavior.
-         * @return A Promise resolved with the write time of this set.
-         */
-        set(data: Partial<T>, options: SetOptions): Promise<WriteResult>;
-        set(data: T): Promise<WriteResult>;
-        /**
-         * Updates fields in the document referred to by this `DocumentReference`.
-         * The update will fail if applied to a document that does not exist.
-         *
-         * Nested fields can be updated by providing dot-separated field path
-         * strings.
-         *
-         * @param data An object containing the fields and values with which to
-         * update the document.
-         * @param precondition A Precondition to enforce on this update.
-         * @return A Promise resolved with the write time of this update.
-         */
-        update(data: UpdateData, precondition?: Precondition): Promise<WriteResult>;
-        /**
-         * Updates fields in the document referred to by this `DocumentReference`.
-         * The update will fail if applied to a document that does not exist.
-         *
-         * Nested fields can be updated by providing dot-separated field path
-         * strings or by providing FieldPath objects.
-         *
-         * A `Precondition` restricting this update can be specified as the last
-         * argument.
-         *
-         * @param field The first field to update.
-         * @param value The first value.
-         * @param moreFieldsOrPrecondition An alternating list of field paths and
-         * values to update, optionally followed by a `Precondition` to enforce on
-         * this update.
-         * @return A Promise resolved with the write time of this update.
-         */
-        update(field: string | FieldPath, value: any, ...moreFieldsOrPrecondition: any[]): Promise<WriteResult>;
-        /**
-         * Deletes the document referred to by this `DocumentReference`.
-         *
-         * @param precondition A Precondition to enforce for this delete.
-         * @return A Promise resolved with the write time of this delete.
-         */
-        delete(precondition?: Precondition): Promise<WriteResult>;
-        /**
-         * Reads the document referred to by this `DocumentReference`.
-         *
-         * @return A Promise resolved with a DocumentSnapshot containing the
-         * current document contents.
-         */
-        get(): Promise<DocumentSnapshot<T>>;
-        /**
-         * Attaches a listener for DocumentSnapshot events.
-         *
-         * @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.
-         * @return An unsubscribe function that can be called to cancel
-         * the snapshot listener.
-         */
-        onSnapshot(onNext: (snapshot: DocumentSnapshot<T>) => void, onError?: (error: Error) => void): () => void;
-        /**
-         * Returns true if this `DocumentReference` is equal to the provided one.
-         *
-         * @param other The `DocumentReference` to compare against.
-         * @return true if this `DocumentReference` is equal to the provided one.
-         */
-        isEqual(other: DocumentReference<T>): boolean;
-        /**
-         * Applies a custom data converter to this DocumentReference, allowing you
-         * to use your own custom model objects with Firestore. When you call
-         * set(), get(), etc. on the returned DocumentReference instance, the
-         * provided converter will convert between Firestore data and your custom
-         * type U.
-         *
-         * @param converter Converts objects to and from Firestore. Passing in
-         * `null` removes the current converter.
-         * @return A DocumentReference<U> that uses the provided converter.
-         */
-        withConverter<U>(converter: FirestoreDataConverter<U>): DocumentReference<U>;
-        withConverter(converter: null): DocumentReference<DocumentData>;
-    }
-    /**
-     * A `DocumentSnapshot` contains data read from a document in your Firestore
-     * database. The data can be extracted with `.data()` or `.get(<field>)` to
-     * get a specific field.
-     *
-     * For a `DocumentSnapshot` that points to a non-existing document, any data
-     * access will return 'undefined'. You can use the `exists` property to
-     * explicitly verify a document's existence.
-     */
-    class DocumentSnapshot<T = DocumentData> {
-        protected constructor();
-        /** True if the document exists. */
-        readonly exists: boolean;
-        /** A `DocumentReference` to the document location. */
-        readonly ref: DocumentReference<T>;
-        /**
-         * The ID of the document for which this `DocumentSnapshot` contains data.
-         */
-        readonly id: string;
-        /**
-         * The time the document was created. Not set for documents that don't
-         * exist.
-         */
-        readonly createTime?: Timestamp;
-        /**
-         * The time the document was last updated (at the time the snapshot was
-         * generated). Not set for documents that don't exist.
-         */
-        readonly updateTime?: Timestamp;
-        /**
-         * The time this snapshot was read.
-         */
-        readonly readTime: Timestamp;
-        /**
-         * Retrieves all fields in the document as an Object. Returns 'undefined' if
-         * the document doesn't exist.
-         *
-         * @return An Object containing all fields in the document.
-         */
-        data(): T | undefined;
-        /**
-         * Retrieves the field specified by `fieldPath`.
-         *
-         * @param fieldPath The path (e.g. 'foo' or 'foo.bar') to a specific field.
-         * @return The data at the specified field location or undefined if no such
-         * field exists in the document.
-         */
-        get(fieldPath: string | FieldPath): any;
-        /**
-         * Returns true if the document's data and path in this `DocumentSnapshot`
-         * is equal to the provided one.
-         *
-         * @param other The `DocumentSnapshot` to compare against.
-         * @return true if this `DocumentSnapshot` is equal to the provided one.
-         */
-        isEqual(other: DocumentSnapshot<T>): 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` property will always be true and `data()` will never return
-     * 'undefined'.
-     */
-    class QueryDocumentSnapshot<T = DocumentData> extends DocumentSnapshot<T> {
-        private constructor();
-        /**
-         * The time the document was created.
-         */
-        readonly createTime: Timestamp;
-        /**
-         * The time the document was last updated (at the time the snapshot was
-         * generated).
-         */
-        readonly updateTime: Timestamp;
-        /**
-         * Retrieves all fields in the document as an Object.
-         *
-         * @override
-         * @return An Object containing all fields in the document.
-         */
-        data(): T;
-    }
-    /**
-     * The direction of a `Query.orderBy()` clause is specified as 'desc' or 'asc'
-     * (descending or ascending).
-     */
-    type OrderByDirection = 'desc' | 'asc';
-    /**
-     * Filter conditions in a `Query.where()` clause are specified using the
-     * strings '<', '<=', '==', '!=', '>=', '>', 'array-contains', 'in', 'not-in',
-     * and 'array-contains-any'.
-     */
-    type WhereFilterOp = '<' | '<=' | '==' | '!=' | '>=' | '>' | 'array-contains' | 'in' | 'not-in' | 'array-contains-any';
-    /**
-     * 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.
-     */
-    class Query<T = DocumentData> {
-        protected constructor();
-        /**
-         * The `Firestore` for the Firestore database (useful for performing
-         * transactions, etc.).
-         */
-        readonly firestore: Firestore;
-        /**
-         * Creates and returns a new Query with the additional filter that documents
-         * must contain the specified field and that its value should satisfy the
-         * relation constraint provided.
-         *
-         * This function returns a new (immutable) instance of the Query (rather
-         * than modify the existing instance) to impose the filter.
-         *
-         * @param fieldPath The path to compare
-         * @param opStr The operation string (e.g "<", "<=", "==", ">", ">=").
-         * @param value The value for comparison
-         * @return The created Query.
-         */
-        where(fieldPath: string | FieldPath, opStr: WhereFilterOp, value: any): Query<T>;
-        /**
-         * Creates and returns a new Query that's additionally sorted by the
-         * specified field, optionally in descending order instead of ascending.
-         *
-         * This function returns a new (immutable) instance of the Query (rather
-         * than modify the existing instance) to impose the order.
-         *
-         * @param fieldPath The field to sort by.
-         * @param directionStr Optional direction to sort by ('asc' or 'desc'). If
-         * not specified, order will be ascending.
-         * @return The created Query.
-         */
-        orderBy(fieldPath: string | FieldPath, directionStr?: OrderByDirection): Query<T>;
-        /**
-         * Creates and returns a new Query that only returns the first matching
-         * documents.
-         *
-         * This function returns a new (immutable) instance of the Query (rather
-         * than modify the existing instance) to impose the limit.
-         *
-         * @param limit The maximum number of items to return.
-         * @return The created Query.
-         */
-        limit(limit: number): Query<T>;
-        /**
-         * Creates and returns a new Query that only returns the last matching
-         * documents.
-         *
-         * You must specify at least one orderBy clause for limitToLast queries,
-         * otherwise an exception will be thrown during execution.
-         *
-         * Results for limitToLast queries cannot be streamed via the `stream()`
-         * API.
-         *
-         * @param limit The maximum number of items to return.
-         * @return The created Query.
-         */
-        limitToLast(limit: number): Query<T>;
-        /**
-         * Specifies the offset of the returned results.
-         *
-         * This function returns a new (immutable) instance of the Query (rather
-         * than modify the existing instance) to impose the offset.
-         *
-         * @param offset The offset to apply to the Query results.
-         * @return The created Query.
-         */
-        offset(offset: number): Query<T>;
-        /**
-         * Creates and returns a new Query instance that applies a field mask to
-         * the result and returns only the specified subset of fields. You can
-         * specify a list of field paths to return, or use an empty list to only
-         * return the references of matching documents.
-         *
-         * Queries that contain field masks cannot be listened to via `onSnapshot()`
-         * listeners.
-         *
-         * This function returns a new (immutable) instance of the Query (rather
-         * than modify the existing instance) to impose the field mask.
-         *
-         * @param field The field paths to return.
-         * @return The created Query.
-         */
-        select(...field: (string | FieldPath)[]): Query<DocumentData>;
-        /**
-         * Creates and returns a new Query that starts at the provided document
-         * (inclusive). The starting position is relative to the order of the query.
-         * The document must contain all of the fields provided in the orderBy of
-         * this query.
-         *
-         * @param snapshot The snapshot of the document to start after.
-         * @return The created Query.
-         */
-        startAt(snapshot: DocumentSnapshot<any>): Query<T>;
-        /**
-         * 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.
-         *
-         * @param fieldValues The field values to start this query at, in order
-         * of the query's order by.
-         * @return The created Query.
-         */
-        startAt(...fieldValues: any[]): Query<T>;
-        /**
-         * Creates and returns a new Query that starts after the provided document
-         * (exclusive). The starting position is relative to the order of the query.
-         * The document must contain all of the fields provided in the orderBy of
-         * this query.
-         *
-         * @param snapshot The snapshot of the document to start after.
-         * @return The created Query.
-         */
-        startAfter(snapshot: DocumentSnapshot<any>): Query<T>;
-        /**
-         * 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.
-         *
-         * @param fieldValues The field values to start this query after, in order
-         * of the query's order by.
-         * @return The created Query.
-         */
-        startAfter(...fieldValues: any[]): Query<T>;
-        /**
-         * Creates and returns a new Query that ends before the provided document
-         * (exclusive). The end position is relative to the order of the query. The
-         * document must contain all of the fields provided in the orderBy of this
-         * query.
-         *
-         * @param snapshot The snapshot of the document to end before.
-         * @return The created Query.
-         */
-        endBefore(snapshot: DocumentSnapshot<any>): Query<T>;
-        /**
-         * 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.
-         *
-         * @param fieldValues The field values to end this query before, in order
-         * of the query's order by.
-         * @return The created Query.
-         */
-        endBefore(...fieldValues: any[]): Query<T>;
-        /**
-         * Creates and returns a new Query that ends at the provided document
-         * (inclusive). The end position is relative to the order of the query. The
-         * document must contain all of the fields provided in the orderBy of this
-         * query.
-         *
-         * @param snapshot The snapshot of the document to end at.
-         * @return The created Query.
-         */
-        endAt(snapshot: DocumentSnapshot<any>): Query<T>;
-        /**
-         * 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.
-         *
-         * @param fieldValues The field values to end this query at, in order
-         * of the query's order by.
-         * @return The created Query.
-         */
-        endAt(...fieldValues: any[]): Query<T>;
-        /**
-         * Executes the query and returns the results as a `QuerySnapshot`.
-         *
-         * @return A Promise that will be resolved with the results of the Query.
-         */
-        get(): Promise<QuerySnapshot<T>>;
-        stream(): NodeJS.ReadableStream;
-        /**
-         * Attaches a listener for `QuerySnapshot `events.
-         *
-         * @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.
-         * @return An unsubscribe function that can be called to cancel
-         * the snapshot listener.
-         */
-        onSnapshot(onNext: (snapshot: QuerySnapshot<T>) => void, onError?: (error: Error) => void): () => void;
-        /**
-         * Returns true if this `Query` is equal to the provided one.
-         *
-         * @param other The `Query` to compare against.
-         * @return true if this `Query` is equal to the provided one.
-         */
-        isEqual(other: Query<T>): boolean;
-        /**
-         * 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.
-         *
-         * @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<U>(converter: FirestoreDataConverter<U>): Query<U>;
-        withConverter(converter: null): Query<DocumentData>;
-    }
-    /**
-     * 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.
-     */
-    class QuerySnapshot<T = DocumentData> {
-        private constructor();
-        /**
-         * The query on which you called `get` or `onSnapshot` in order to get this
-         * `QuerySnapshot`.
-         */
-        readonly query: Query<T>;
-        /** An array of all the documents in the QuerySnapshot. */
-        readonly docs: Array<QueryDocumentSnapshot<T>>;
-        /** The number of documents in the QuerySnapshot. */
-        readonly size: number;
-        /** True if there are no documents in the QuerySnapshot. */
-        readonly empty: boolean;
-        /** The time this query snapshot was obtained. */
-        readonly readTime: Timestamp;
-        /**
-         * 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.
-         */
-        docChanges(): DocumentChange<T>[];
-        /**
-         * Enumerates all of the documents in the QuerySnapshot.
-         *
-         * @param callback A callback to be called with a `DocumentSnapshot` for
-         * each document in the snapshot.
-         * @param thisArg The `this` binding for the callback.
-         */
-        forEach(callback: (result: QueryDocumentSnapshot<T>) => void, thisArg?: any): void;
-        /**
-         * Returns true if the document data in this `QuerySnapshot` is equal to the
-         * provided one.
-         *
-         * @param other The `QuerySnapshot` to compare against.
-         * @return true if this `QuerySnapshot` is equal to the provided one.
-         */
-        isEqual(other: QuerySnapshot<T>): boolean;
-    }
-    /**
-     * The type of of a `DocumentChange` may be 'added', 'removed', or 'modified'.
-     */
-    type DocumentChangeType = 'added' | 'removed' | 'modified';
-    /**
-     * A `DocumentChange` represents a change to the documents matching a query.
-     * It contains the document affected and the type of change that occurred.
-     */
-    interface DocumentChange<T = DocumentData> {
-        /** The type of change ('added', 'modified', or 'removed'). */
-        readonly type: DocumentChangeType;
-        /** The document affected by this change. */
-        readonly doc: QueryDocumentSnapshot<T>;
-        /**
-         * 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.
-         */
-        readonly oldIndex: number;
-        /**
-         * The index of the changed document in the result set immediately after
-         * this DocumentChange (i.e. supposing that all prior DocumentChange
-         * objects and the current DocumentChange object have been applied).
-         * Is -1 for 'removed' events.
-         */
-        readonly newIndex: number;
-        /**
-         * Returns true if the data in this `DocumentChange` is equal to the
-         * provided one.
-         *
-         * @param other The `DocumentChange` to compare against.
-         * @return true if this `DocumentChange` is equal to the provided one.
-         */
-        isEqual(other: DocumentChange<T>): boolean;
-    }
-    /**
-     * A `CollectionReference` object can be used for adding documents, getting
-     * document references, and querying for documents (using the methods
-     * inherited from `Query`).
-     */
-    class CollectionReference<T = DocumentData> extends Query<T> {
-        private constructor();
-        /** The identifier of the collection. */
-        readonly id: string;
-        /**
-         * A reference to the containing Document if this is a subcollection, else
-         * null.
-         */
-        readonly parent: DocumentReference<DocumentData> | null;
-        /**
-         * A string representing the path of the referenced collection (relative
-         * to the root of the database).
-         */
-        readonly path: string;
-        /**
-         * Retrieves the list of documents in this collection.
-         *
-         * The document references returned may include references to "missing
-         * documents", i.e. document locations that have no document present but
-         * which contain subcollections with documents. Attempting to read such a
-         * document reference (e.g. via `.get()` or `.onSnapshot()`) will return a
-         * `DocumentSnapshot` whose `.exists` property is false.
-         *
-         * @return {Promise<DocumentReference[]>} The list of documents in this
-         * collection.
-         */
-        listDocuments(): Promise<Array<DocumentReference<T>>>;
-        /**
-         * Get a `DocumentReference` for a randomly-named document within this
-         * collection. An automatically-generated unique ID will be used as the
-         * document ID.
-         *
-         * @return The `DocumentReference` instance.
-         */
-        doc(): DocumentReference<T>;
-        /**
-         * Get a `DocumentReference` for the document within the collection at the
-         * specified path.
-         *
-         * @param documentPath A slash-separated path to a document.
-         * @return The `DocumentReference` instance.
-         */
-        doc(documentPath: string): DocumentReference<T>;
-        /**
-         * Add a new document to this collection with the specified data, assigning
-         * it a document ID automatically.
-         *
-         * @param data An Object containing the data for the new document.
-         * @return A Promise resolved with a `DocumentReference` pointing to the
-         * newly created document after it has been written to the backend.
-         */
-        add(data: T): Promise<DocumentReference<T>>;
-        /**
-         * Returns true if this `CollectionReference` is equal to the provided one.
-         *
-         * @param other The `CollectionReference` to compare against.
-         * @return true if this `CollectionReference` is equal to the provided one.
-         */
-        isEqual(other: CollectionReference<T>): boolean;
-        /**
-         * 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.
-         *
-         * @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<U>(converter: FirestoreDataConverter<U>): CollectionReference<U>;
-        withConverter(converter: null): CollectionReference<DocumentData>;
-    }
-    /**
-     * A `CollectionGroup` refers to all documents that are contained in a
-     * collection or subcollection with a specific collection ID.
-     */
-    class CollectionGroup<T = DocumentData> extends Query<T> {
-        private constructor();
-        /**
-         * Partitions a query by returning partition cursors that can be used to run
-         * the query in parallel. The returned cursors are split points that can be
-         * used as starting and end points for individual query invocations.
-         *
-         * @param desiredPartitionCount The desired maximum number of partition
-         * points. The number must be strictly positive. The actual number of
-         * partitions returned may be fewer.
-         * @return An AsyncIterable of `QueryPartition`s.
-         */
-        getPartitions(desiredPartitionCount: number): AsyncIterable<QueryPartition<T>>;
-        /**
-         * Applies a custom data converter to this `CollectionGroup`, allowing you
-         * to use your own custom model objects with Firestore. When you call get()
-         * on the returned `CollectionGroup`, the provided converter will convert
-         * between Firestore data and your custom type U.
-         *
-         * Using the converter allows you to specify generic type arguments when
-         * storing and retrieving objects from Firestore.
-         *
-         * @example
-         * class Post {
-         *   constructor(readonly title: string, readonly author: string) {}
-         *
-         *   toString(): string {
-         *     return this.title + ', by ' + this.author;
-         *   }
-         * }
-         *
-         * const postConverter = {
-         *   toFirestore(post: Post): FirebaseFirestore.DocumentData {
-         *     return {title: post.title, author: post.author};
-         *   },
-         *   fromFirestore(
-         *     snapshot: FirebaseFirestore.QueryDocumentSnapshot
-         *   ): Post {
-         *     const data = snapshot.data();
-         *     return new Post(data.title, data.author);
-         *   }
-         * };
-         *
-         * const querySnapshot = await Firestore()
-         *   .collectionGroup('posts')
-         *   .withConverter(postConverter)
-         *   .get();
-         * for (const doc of querySnapshot.docs) {
-         *   const post = doc.data();
-         *   post.title; // string
-         *   post.toString(); // Should be defined
-         *   post.someNonExistentProperty; // TS error
-         * }
-         *
-         * @param converter Converts objects to and from Firestore. Passing in
-         * `null` removes the current converter.
-         * @return A `CollectionGroup<U>` that uses the provided converter.
-         */
-        withConverter<U>(converter: FirestoreDataConverter<U>): CollectionGroup<U>;
-        withConverter(converter: null): CollectionGroup<DocumentData>;
-    }
-    /**
-     * A split point that can be used in a query as a starting and/or end point for
-     * the query results. The cursors returned by {@link #startAt} and {@link
-     * #endBefore} can only be used in a query that matches the constraint of query
-     * that produced this partition.
-     */
-    class QueryPartition<T = DocumentData> {
-        private constructor();
-        /**
-         * The cursor that defines the first result for this partition or
-         * `undefined` if this is the first partition.  The cursor value must be
-         * destructured when passed to `startAt()` (for example with
-         * `query.startAt(...queryPartition.startAt)`).
-         *
-         * @return Cursor values that can be used with {@link Query#startAt} or
-         * `undefined` if this is the first partition.
-         */
-        get startAt(): unknown[] | undefined;
-        /**
-         * The cursor that defines the first result after this partition or
-         * `undefined` if this is the last partition.  The cursor value must be
-         * destructured when passed to `endBefore()` (for example with
-         * `query.endBefore(...queryPartition.endBefore)`).
-         *
-         * @return Cursor values that can be used with {@link Query#endBefore} or
-         * `undefined` if this is the last partition.
-         */
-        get endBefore(): unknown[] | undefined;
-        /**
-         * Returns a query that only returns the documents for this partition.
-         *
-         * @return A query partitioned by a {@link Query#startAt} and {@link
-         * Query#endBefore} cursor.
-         */
-        toQuery(): Query<T>;
-    }
-    /**
-     * Sentinel values that can be used when writing document fields with set(),
-     * create() or update().
-     */
-    class FieldValue {
-        private constructor();
-        /**
-         * Returns a sentinel used with set(), create() or update() to include a
-         * server-generated timestamp in the written data.
-         *
-         * @return The FieldValue sentinel for use in a call to set(), create() or
-         * update().
-         */
-        static serverTimestamp(): FieldValue;
-        /**
-         * Returns a sentinel for use with update() or set() with {merge:true} to
-         * mark a field for deletion.
-         *
-         * @return The FieldValue sentinel for use in a call to set() or update().
-         */
-        static delete(): FieldValue;
-        /**
-         * Returns a special value that can be used with set(), create() or update()
-         * that tells the server to increment the field's current value by the given
-         * value.
-         *
-         * If either current field value or the operand uses floating point
-         * precision, both values will be interpreted as floating point numbers and
-         * all arithmetic will follow IEEE 754 semantics. Otherwise, integer
-         * precision is kept and the result is 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 will set the field to the given value.
-         *
-         * @param n The value to increment by.
-         * @return The FieldValue sentinel for use in a call to set(), create() or
-         * update().
-         */
-        static increment(n: number): FieldValue;
-        /**
-         * Returns a special value that can be used with set(), create() 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.
-         *
-         * @param elements The elements to union into the array.
-         * @return The FieldValue sentinel for use in a call to set(), create() or
-         * update().
-         */
-        static arrayUnion(...elements: any[]): FieldValue;
-        /**
-         * Returns a special value that can be used with set(), create() 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.
-         *
-         * @param elements The elements to remove from the array.
-         * @return The FieldValue sentinel for use in a call to set(), create() or
-         * update().
-         */
-        static arrayRemove(...elements: any[]): FieldValue;
-        /**
-         * Returns true if this `FieldValue` is equal to the provided one.
-         *
-         * @param other The `FieldValue` to compare against.
-         * @return true if this `FieldValue` is equal to the provided one.
-         */
-        isEqual(other: FieldValue): boolean;
-    }
-    /**
-     * 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).
-     */
-    class 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.
-         *
-         * @param fieldNames A list of field names.
-         */
-        constructor(...fieldNames: string[]);
-        /**
-         * 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;
-        /**
-         * Returns true if this `FieldPath` is equal to the provided one.
-         *
-         * @param other The `FieldPath` to compare against.
-         * @return true if this `FieldPath` is equal to the provided one.
-         */
-        isEqual(other: FieldPath): 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.
-     *
-     * @see https://github.com/google/protobuf/blob/master/src/google/protobuf/timestamp.proto
-     */
-    class Timestamp {
-        /**
-         * Creates a new timestamp with the current date, with millisecond precision.
-         *
-         * @return A new `Timestamp` representing the current date.
-         */
-        static now(): Timestamp;
-        /**
-         * Creates a new timestamp from the given date.
-         *
-         * @param date The date to initialize the `Timestamp` from.
-         * @return A new `Timestamp` representing the same point in time as the
-         * given date.
-         */
-        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.
-         * @return A new `Timestamp` representing the same point in time as the
-         * given number of milliseconds.
-         */
-        static fromMillis(milliseconds: number): 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 seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z.
-         */
-        readonly seconds: number;
-        /** The non-negative fractions of a second at nanosecond resolution. */
-        readonly nanoseconds: number;
-        /**
-         * Returns a new `Date` corresponding to this timestamp. This may lose
-         * precision.
-         *
-         * @return JavaScript `Date` object representing the same point in time as
-         * this `Timestamp`, with millisecond precision.
-         */
-        toDate(): Date;
-        /**
-         * Returns the number of milliseconds since Unix epoch 1970-01-01T00:00:00Z.
-         *
-         * @return The point in time corresponding to this timestamp, represented as
-         * the number of milliseconds since Unix epoch 1970-01-01T00:00:00Z.
-         */
-        toMillis(): number;
-        /**
-         * Returns true if this `Timestamp` is equal to the provided one.
-         *
-         * @param other The `Timestamp` to compare against.
-         * @return 'true' if this `Timestamp` is equal to the provided one.
-         */
-        isEqual(other: Timestamp): boolean;
-        /**
-         * Converts this object to a primitive `string`, which allows `Timestamp` objects to be compared
-         * using the `>`, `<=`, `>=` and `>` operators.
-         *
-         * @return a string encoding of this object.
-         */
-        valueOf(): string;
-    }
-    /**
-     * Builds a Firestore data bundle with results from the given document and query snapshots.
-     */
-    class BundleBuilder {
-        /** The ID of this bundle. */
-        readonly bundleId: string;
-        /**
-         * Adds a Firestore `DocumentSnapshot` to the bundle. Both the documents data and the document
-         * read time will be included in the bundle.
-         *
-         * @param documentSnapshot A `DocumentSnapshot` to add.
-         * @returns This instance.
-         */
-        add<T>(documentSnapshot: DocumentSnapshot<T>): BundleBuilder;
-        /**
-         * Adds a Firestore `QuerySnapshot` to the bundle. Both the documents in the query results and
-         * the query read time will be included in the bundle.
-         *
-         * @param queryName The name of the query to add.
-         * @param querySnapshot A `QuerySnapshot` to add to the bundle.
-         * @returns This instance.
-         */
-        add<T>(queryName: string, querySnapshot: QuerySnapshot<T>): BundleBuilder;
-        /**
-         * Builds the bundle and returns the result as a `Buffer` instance.
-         */
-        build(): Buffer;
-    }
-    /**
-     * The v1beta1 Veneer client. This client provides access to to the underlying
-     * Firestore v1beta1 RPCs.
-     * @deprecated Use v1 instead.
-     */
-    /**
-     * The v1 Veneer clients. These clients provide access to the Firestore Admin
-     * API and the underlying Firestore v1 RPCs.
-     */
-    /**
-     * Status codes returned by Firestore's gRPC calls.
-     */
-    enum GrpcStatus {
-        OK = 0,
-        CANCELLED = 1,
-        UNKNOWN = 2,
-        INVALID_ARGUMENT = 3,
-        DEADLINE_EXCEEDED = 4,
-        NOT_FOUND = 5,
-        ALREADY_EXISTS = 6,
-        PERMISSION_DENIED = 7,
-        RESOURCE_EXHAUSTED = 8,
-        FAILED_PRECONDITION = 9,
-        ABORTED = 10,
-        OUT_OF_RANGE = 11,
-        UNIMPLEMENTED = 12,
-        INTERNAL = 13,
-        UNAVAILABLE = 14,
-        DATA_LOSS = 15,
-        UNAUTHENTICATED = 16
-    }
-}
-declare module 'firestore-types' {
-    export = FirebaseFirestoreTypes;
-}