@glissandoo/lib 1.123.2 → 1.124.0-dev.219.1

package/types/firestore.d.ts

@@ -0,0 +1,1746 @@
+/*!
+ * 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.
+ */
+/**
+ * Document data (for use with `DocumentReference.set()`) consists of fields
+ * mapped to values.
+ */
+export 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.
+ */
+export type UpdateData = {
+    [fieldPath: string]: any;
+};
+/**
+ * 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
+ * }
+ */
+export 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.
+ */
+export 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.
+ */
+export declare 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].
+ */
+export declare 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()`.
+ */
+export declare 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
+ */
+export declare 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.
+ */
+export 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.
+ */
+export declare 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.
+ */
+export declare 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.
+ */
+export 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.
+ */
+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.
+     */
+    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.
+ */
+export 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()`.
+ */
+export declare 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.
+ */
+export declare 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.
+ */
+export declare 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'.
+ */
+export declare 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).
+ */
+export 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'.
+ */
+export 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.
+ */
+export declare 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.
+ */
+export declare 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'.
+ */
+export 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.
+ */
+export 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`).
+ */
+export declare 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.
+ */
+export declare 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.
+ */
+export declare 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().
+ */
+export declare 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).
+ */
+export declare 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
+ */
+export declare 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.
+ */
+export declare 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.
+ */
+export declare 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
+}