@firebase/firestore 3.5.0 → 3.6.0

package/dist/index.node.cjs.js

@@ -33,7 +33,7 @@ var grpc__namespace = /*#__PURE__*/_interopNamespace(grpc);
 var protoLoader__namespace = /*#__PURE__*/_interopNamespace(protoLoader);
 
 const name = "@firebase/firestore";
-const version$1 = "3.5.0";
+const version$1 = "3.6.0";
 
 /**
  * @license
@@ -86,7 +86,7 @@ User.GOOGLE_CREDENTIALS = new User('google-credentials-uid');
 User.FIRST_PARTY = new User('first-party-uid');
 User.MOCK_USER = new User('mock-user');
 
-const version = "9.10.0";
+const version = "9.11.0";
 
 /**
  * @license
@@ -8751,6 +8751,21 @@ function toQueryTarget(serializer, target) {
     }
     return result;
 }
+function toRunAggregationQueryRequest(serializer, target) {
+    const queryTarget = toQueryTarget(serializer, target);
+    return {
+        structuredAggregationQuery: {
+            aggregations: [
+                {
+                    count: {},
+                    alias: 'count_alias'
+                }
+            ],
+            structuredQuery: queryTarget.structuredQuery
+        },
+        parent: queryTarget.parent
+    };
+}
 function convertQueryTargetToQuery(target) {
     let path = fromQueryPath(target.parent);
     const query = target.structuredQuery;
@@ -16137,7 +16152,8 @@ function localStoreGetNewDocumentChanges(localStore, collectionGroup) {
 /** Sets the collection group's maximum read time from the given documents. */
 // PORTING NOTE: Multi-Tab only.
 function setMaxReadTime(localStoreImpl, collectionGroup, changedDocs) {
-    let readTime = SnapshotVersion.min();
+    let readTime = localStoreImpl.collectionGroupReadTime.get(collectionGroup) ||
+        SnapshotVersion.min();
     changedDocs.forEach((_, doc) => {
         if (doc.readTime.compareTo(readTime) > 0) {
             readTime = doc.readTime;
@@ -17429,6 +17445,11 @@ class GrpcConnection {
         this.firestore = protos['google']['firestore']['v1'];
         this.databasePath = `projects/${databaseInfo.databaseId.projectId}/databases/${databaseInfo.databaseId.database}`;
     }
+    get shouldResourcePathBeIncludedInRequest() {
+        // Both `invokeRPC()` and `invokeStreamingRPC()` ignore their `path` arguments, and expect
+        // the "path" to be part of the given `request`.
+        return true;
+    }
     ensureActiveStub() {
         if (!this.cachedStub) {
             logDebug(LOG_TAG$9, 'Creating Firestore stub.');
@@ -18475,6 +18496,15 @@ const nested = {
 							ruby_package: "Google::Cloud::Firestore::V1"
 						},
 						nested: {
+							AggregationResult: {
+								fields: {
+									aggregateFields: {
+										keyType: "string",
+										type: "Value",
+										id: 2
+									}
+								}
+							},
 							DocumentMask: {
 								fields: {
 									fieldPaths: {
@@ -18825,6 +18855,29 @@ const nested = {
 											}
 										]
 									},
+									RunAggregationQuery: {
+										requestType: "RunAggregationQueryRequest",
+										responseType: "RunAggregationQueryResponse",
+										responseStream: true,
+										options: {
+											"(google.api.http).post": "/v1/{parent=projects/*/databases/*/documents}:runAggregationQuery",
+											"(google.api.http).body": "*",
+											"(google.api.http).additional_bindings.post": "/v1/{parent=projects/*/databases/*/documents/*/**}:runAggregationQuery",
+											"(google.api.http).additional_bindings.body": "*"
+										},
+										parsedOptions: [
+											{
+												"(google.api.http)": {
+													post: "/v1/{parent=projects/*/databases/*/documents}:runAggregationQuery",
+													body: "*",
+													additional_bindings: {
+														post: "/v1/{parent=projects/*/databases/*/documents/*/**}:runAggregationQuery",
+														body: "*"
+													}
+												}
+											}
+										]
+									},
 									PartitionQuery: {
 										requestType: "PartitionQueryRequest",
 										responseType: "PartitionQueryResponse",
@@ -19316,6 +19369,63 @@ const nested = {
 									}
 								}
 							},
+							RunAggregationQueryRequest: {
+								oneofs: {
+									queryType: {
+										oneof: [
+											"structuredAggregationQuery"
+										]
+									},
+									consistencySelector: {
+										oneof: [
+											"transaction",
+											"newTransaction",
+											"readTime"
+										]
+									}
+								},
+								fields: {
+									parent: {
+										type: "string",
+										id: 1,
+										options: {
+											"(google.api.field_behavior)": "REQUIRED"
+										}
+									},
+									structuredAggregationQuery: {
+										type: "StructuredAggregationQuery",
+										id: 2
+									},
+									transaction: {
+										type: "bytes",
+										id: 4
+									},
+									newTransaction: {
+										type: "TransactionOptions",
+										id: 5
+									},
+									readTime: {
+										type: "google.protobuf.Timestamp",
+										id: 6
+									}
+								}
+							},
+							RunAggregationQueryResponse: {
+								fields: {
+									result: {
+										type: "AggregationResult",
+										id: 1
+									},
+									transaction: {
+										type: "bytes",
+										id: 2
+									},
+									readTime: {
+										type: "google.protobuf.Timestamp",
+										id: 3
+									}
+								}
+							},
 							PartitionQueryRequest: {
 								oneofs: {
 									queryType: {
@@ -19852,6 +19962,57 @@ const nested = {
 									}
 								}
 							},
+							StructuredAggregationQuery: {
+								oneofs: {
+									queryType: {
+										oneof: [
+											"structuredQuery"
+										]
+									}
+								},
+								fields: {
+									structuredQuery: {
+										type: "StructuredQuery",
+										id: 1
+									},
+									aggregations: {
+										rule: "repeated",
+										type: "Aggregation",
+										id: 3
+									}
+								},
+								nested: {
+									Aggregation: {
+										oneofs: {
+											operator: {
+												oneof: [
+													"count"
+												]
+											}
+										},
+										fields: {
+											count: {
+												type: "Count",
+												id: 1
+											},
+											alias: {
+												type: "string",
+												id: 7
+											}
+										},
+										nested: {
+											Count: {
+												fields: {
+													upTo: {
+														type: "google.protobuf.Int64Value",
+														id: 1
+													}
+												}
+											}
+										}
+									}
+								}
+							},
 							Cursor: {
 								fields: {
 									values: {
@@ -21092,6 +21253,19 @@ async function invokeBatchGetDocumentsRpc(datastore, keys) {
     });
     return result;
 }
+async function invokeRunAggregationQueryRpc(datastore, query) {
+    const datastoreImpl = debugCast(datastore);
+    const request = toRunAggregationQueryRequest(datastoreImpl.serializer, queryToTarget(query));
+    const parent = request.parent;
+    if (!datastoreImpl.connection.shouldResourcePathBeIncludedInRequest) {
+        delete request.parent;
+    }
+    const response = await datastoreImpl.invokeStreamingRPC('RunAggregationQuery', parent, request, /*expectedResponseCount=*/ 1);
+    return (response
+        // Omit RunAggregationQueryResponse that only contain readTimes.
+        .filter(proto => !!proto.result)
+        .map(proto => proto.result.aggregateFields));
+}
 function newPersistentWriteStream(datastore, queue, listener) {
     const datastoreImpl = debugCast(datastore);
     datastoreImpl.verifyInitialized();
@@ -23649,10 +23823,15 @@ async function syncEngineEmitNewSnapsAndNotifyLocalStore(syncEngine, changes, re
         queriesProcessed.push(syncEngineImpl
             .applyDocChanges(queryView, changes, remoteEvent)
             .then(viewSnapshot => {
-            if (viewSnapshot) {
+            // If there are changes, or we are handling a global snapshot, notify
+            // secondary clients to update query state.
+            if (viewSnapshot || remoteEvent) {
                 if (syncEngineImpl.isPrimaryClient) {
-                    syncEngineImpl.sharedClientState.updateQueryState(queryView.targetId, viewSnapshot.fromCache ? 'not-current' : 'current');
+                    syncEngineImpl.sharedClientState.updateQueryState(queryView.targetId, (viewSnapshot === null || viewSnapshot === void 0 ? void 0 : viewSnapshot.fromCache) ? 'not-current' : 'current');
                 }
+            }
+            // Update views if there are actual changes.
+            if (!!viewSnapshot) {
                 newSnaps.push(viewSnapshot);
                 const docChanges = LocalViewChanges.fromSnapshot(queryView.targetId, viewSnapshot);
                 docChangesInAllViews.push(docChanges);
@@ -24698,6 +24877,100 @@ function newBundleReader(reader, serializer) {
     return new BundleReaderImpl(reader, serializer);
 }
 
+/**
+ * @license
+ * Copyright 2022 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.
+ */
+/**
+ * Represents an aggregation that can be performed by Firestore.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+class AggregateField {
+    constructor() {
+        /** A type string to uniquely identify instances of this class. */
+        this.type = 'AggregateField';
+    }
+}
+/**
+ * The results of executing an aggregation query.
+ */
+class AggregateQuerySnapshot {
+    /** @hideconstructor */
+    constructor(query, _data) {
+        this._data = _data;
+        /** A type string to uniquely identify instances of this class. */
+        this.type = 'AggregateQuerySnapshot';
+        this.query = query;
+    }
+    /**
+     * Returns the results of the aggregations performed over the underlying
+     * query.
+     *
+     * The keys of the returned object will be the same as those of the
+     * `AggregateSpec` object specified to the aggregation method, and the values
+     * will be the corresponding aggregation result.
+     *
+     * @returns The results of the aggregations performed over the underlying
+     * query.
+     */
+    data() {
+        return this._data;
+    }
+}
+
+/**
+ * @license
+ * Copyright 2022 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.
+ */
+/**
+ * CountQueryRunner encapsulates the logic needed to run the count aggregation
+ * queries.
+ */
+class CountQueryRunner {
+    constructor(query, datastore, userDataWriter) {
+        this.query = query;
+        this.datastore = datastore;
+        this.userDataWriter = userDataWriter;
+    }
+    run() {
+        return invokeRunAggregationQueryRpc(this.datastore, this.query._query).then(result => {
+            hardAssert(result[0] !== undefined);
+            const counts = Object.entries(result[0])
+                .filter(([key, value]) => key === 'count_alias')
+                .map(([key, value]) => this.userDataWriter.convertValue(value));
+            const countValue = counts[0];
+            hardAssert(typeof countValue === 'number');
+            return Promise.resolve(new AggregateQuerySnapshot(this.query, {
+                count: countValue
+            }));
+        });
+    }
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -25254,6 +25527,26 @@ function firestoreClientTransaction(client, updateFunction, options) {
     });
     return deferred.promise;
 }
+function firestoreClientRunCountQuery(client, query, userDataWriter) {
+    const deferred = new Deferred();
+    client.asyncQueue.enqueueAndForget(async () => {
+        try {
+            const remoteStore = await getRemoteStore(client);
+            if (!canUseNetwork(remoteStore)) {
+                deferred.reject(new FirestoreError(Code.UNAVAILABLE, 'Failed to get count result because the client is offline.'));
+            }
+            else {
+                const datastore = await getDatastore(client);
+                const result = new CountQueryRunner(query, datastore, userDataWriter).run();
+                deferred.resolve(result);
+            }
+        }
+        catch (e) {
+            deferred.reject(e);
+        }
+    });
+    return deferred.promise;
+}
 async function readDocumentFromCache(localStore, docKey, result) {
     try {
         const document = await localStoreReadDocument(localStore, docKey);
@@ -25509,7 +25802,7 @@ class FirestoreSettingsImpl {
 /**
  * The Cloud Firestore service interface.
  *
- * Do not call this constructor directly. Instead, use {@link getFirestore}.
+ * Do not call this constructor directly. Instead, use {@link (getFirestore:1)}.
  */
 class Firestore$1 {
     /** @hideconstructor */
@@ -26251,7 +26544,7 @@ const CACHE_SIZE_UNLIMITED = LRU_COLLECTION_DISABLED;
 /**
  * The Cloud Firestore service interface.
  *
- * Do not call this constructor directly. Instead, use {@link getFirestore}.
+ * Do not call this constructor directly. Instead, use {@link (getFirestore:1)}.
  */
 class Firestore extends Firestore$1 {
     /** @hideconstructor */
@@ -26276,8 +26569,8 @@ class Firestore extends Firestore$1 {
 /**
  * Initializes a new instance of {@link Firestore} with the provided settings.
  * Can only be called before any other function, including
- * {@link getFirestore}. If the custom settings are empty, this function is
- * equivalent to calling {@link getFirestore}.
+ * {@link (getFirestore:1)}. If the custom settings are empty, this function is
+ * equivalent to calling {@link (getFirestore:1)}.
  *
  * @param app - The {@link @firebase/app#FirebaseApp} with which the {@link Firestore} instance will
  * be associated.
@@ -26320,9 +26613,17 @@ function getFirestore(appOrDatabaseId, optionalDatabaseId) {
     const databaseId = typeof appOrDatabaseId === 'string'
         ? appOrDatabaseId
         : optionalDatabaseId || DEFAULT_DATABASE_NAME;
-    return app._getProvider(app$1, 'firestore').getImmediate({
+    const db = app._getProvider(app$1, 'firestore').getImmediate({
         identifier: databaseId
     });
+    if (!db._initialized) {
+        const firestoreEmulatorHost = util$1.getDefaultEmulatorHost('firestore');
+        if (firestoreEmulatorHost) {
+            const [host, port] = firestoreEmulatorHost.split(':');
+            connectFirestoreEmulator(db, host, parseInt(port, 10));
+        }
+    }
+    return db;
 }
 /**
  * @internal
@@ -26344,7 +26645,7 @@ function configureFirestore(firestore) {
  * Attempts to enable persistent storage, if possible.
  *
  * Must be called before any other functions (other than
- * {@link initializeFirestore}, {@link getFirestore} or
+ * {@link initializeFirestore}, {@link (getFirestore:1)} or
  * {@link clearIndexedDbPersistence}.
  *
  * If this fails, `enableIndexedDbPersistence()` will reject the promise it
@@ -26468,7 +26769,7 @@ function canFallbackFromIndexedDbError(error) {
  * Must be called while the {@link Firestore} instance is not started (after the app is
  * terminated or when the app is first initialized). On startup, this function
  * must be called before other functions (other than {@link
- * initializeFirestore} or {@link getFirestore})). If the {@link Firestore}
+ * initializeFirestore} or {@link (getFirestore:1)})). If the {@link Firestore}
  * instance is still running, the promise will be rejected with the error code
  * of `failed-precondition`.
  *
@@ -26552,7 +26853,7 @@ function disableNetwork(firestore) {
  * may be used. Any other function will throw a `FirestoreError`.
  *
  * To restart after termination, create a new instance of FirebaseFirestore with
- * {@link getFirestore}.
+ * {@link (getFirestore:1)}.
  *
  * Termination does not cancel any pending writes, and any promises that are
  * awaiting a response from the server will not be resolved. If you have
@@ -26651,7 +26952,7 @@ function registerFirestore(variant, useFetchStreams = true) {
 
 /**
  * @license
- * Copyright 2020 Google LLC
+ * Copyright 2017 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26665,46 +26966,24 @@ function registerFirestore(variant, useFetchStreams = true) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+function isPartialObserver(obj) {
+    return implementsAnyMethods(obj, ['next', 'error', 'complete']);
+}
 /**
- * A `FieldPath` refers to a field in a document. The path may consist of a
- * single field name (referring to a top-level field in the document), or a
- * list of field names (referring to a nested field in the document).
- *
- * Create a `FieldPath` by providing field names. If more than one field
- * name is provided, the path will point to a nested field in a document.
+ * Returns true if obj is an object and contains at least one of the specified
+ * methods.
  */
-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) {
-        for (let i = 0; i < fieldNames.length; ++i) {
-            if (fieldNames[i].length === 0) {
-                throw new FirestoreError(Code.INVALID_ARGUMENT, `Invalid field name at argument $(i + 1). ` +
-                    'Field names must not be empty.');
-            }
-        }
-        this._internalPath = new FieldPath$1(fieldNames);
+function implementsAnyMethods(obj, methods) {
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
     }
-    /**
-     * Returns true if this `FieldPath` is equal to the provided one.
-     *
-     * @param other - The `FieldPath` to compare against.
-     * @returns true if this `FieldPath` is equal to the provided one.
-     */
-    isEqual(other) {
-        return this._internalPath.isEqual(other._internalPath);
+    const object = obj;
+    for (const method of methods) {
+        if (method in object && typeof object[method] === 'function') {
+            return true;
+        }
     }
-}
-/**
- * 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.
- */
-function documentId() {
-    return new FieldPath(DOCUMENT_KEY_NAME);
+    return false;
 }
 
 /**
@@ -26805,11 +27084,69 @@ class Bytes {
  * limitations under the License.
  */
 /**
- * Sentinel values that can be used when writing document fields with `set()`
- * or `update()`.
- */
-class FieldValue {
-    /**
+ * A `FieldPath` refers to a field in a document. The path may consist of a
+ * single field name (referring to a top-level field in the document), or a
+ * list of field names (referring to a nested field in the document).
+ *
+ * Create a `FieldPath` by providing field names. If more than one field
+ * name is provided, the path will point to a nested field in a document.
+ */
+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) {
+        for (let i = 0; i < fieldNames.length; ++i) {
+            if (fieldNames[i].length === 0) {
+                throw new FirestoreError(Code.INVALID_ARGUMENT, `Invalid field name at argument $(i + 1). ` +
+                    'Field names must not be empty.');
+            }
+        }
+        this._internalPath = new FieldPath$1(fieldNames);
+    }
+    /**
+     * Returns true if this `FieldPath` is equal to the provided one.
+     *
+     * @param other - The `FieldPath` to compare against.
+     * @returns true if this `FieldPath` is equal to the provided one.
+     */
+    isEqual(other) {
+        return this._internalPath.isEqual(other._internalPath);
+    }
+}
+/**
+ * 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.
+ */
+function documentId() {
+    return new FieldPath(DOCUMENT_KEY_NAME);
+}
+
+/**
+ * @license
+ * 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.
+ */
+/**
+ * Sentinel values that can be used when writing document fields with `set()`
+ * or `update()`.
+ */
+class FieldValue {
+    /**
      * @param _methodName - The public API endpoint that returns this class.
      * @hideconstructor
      */
@@ -27710,378 +28047,87 @@ function fieldPathFromArgument(methodName, arg) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+function validateHasExplicitOrderByForLimitToLast(query) {
+    if (query.limitType === "L" /* Last */ &&
+        query.explicitOrderBy.length === 0) {
+        throw new FirestoreError(Code.UNIMPLEMENTED, 'limitToLast() queries require specifying at least one orderBy() clause');
+    }
+}
 /**
- * Metadata about a snapshot, describing the state of the snapshot.
+ * A `QueryConstraint` is used to narrow the set of documents returned by a
+ * Firestore query. `QueryConstraint`s are created by invoking {@link where},
+ * {@link orderBy}, {@link (startAt:1)}, {@link (startAfter:1)}, {@link
+ * endBefore:1}, {@link (endAt:1)}, {@link limit} or {@link limitToLast} and
+ * can then be passed to {@link query} to create a new query instance that
+ * also contains this `QueryConstraint`.
  */
-class SnapshotMetadata {
-    /** @hideconstructor */
-    constructor(hasPendingWrites, fromCache) {
-        this.hasPendingWrites = hasPendingWrites;
-        this.fromCache = fromCache;
-    }
-    /**
-     * Returns true if this `SnapshotMetadata` is equal to the provided one.
-     *
-     * @param other - The `SnapshotMetadata` to compare against.
-     * @returns true if this `SnapshotMetadata` is equal to the provided one.
-     */
-    isEqual(other) {
-        return (this.hasPendingWrites === other.hasPendingWrites &&
-            this.fromCache === other.fromCache);
-    }
+class QueryConstraint {
 }
 /**
- * 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.
+ * Creates a new immutable instance of {@link Query} that is extended to also include
+ * additional query constraints.
  *
- * For a `DocumentSnapshot` that points to a non-existing document, any data
- * access will return 'undefined'. You can use the `exists()` method to
- * explicitly verify a document's existence.
+ * @param query - The {@link Query} instance to use as a base for the new constraints.
+ * @param queryConstraints - The list of {@link QueryConstraint}s to apply.
+ * @throws if any of the provided query constraints cannot be combined with the
+ * existing or new constraints.
  */
-class DocumentSnapshot extends DocumentSnapshot$1 {
-    /** @hideconstructor protected */
-    constructor(_firestore, userDataWriter, key, document, metadata, converter) {
-        super(_firestore, userDataWriter, key, document, converter);
-        this._firestore = _firestore;
-        this._firestoreImpl = _firestore;
-        this.metadata = metadata;
-    }
-    /**
-     * Returns whether or not the data exists. True if the document exists.
-     */
-    exists() {
-        return super.exists();
+function query(query, ...queryConstraints) {
+    for (const constraint of queryConstraints) {
+        query = constraint._apply(query);
     }
-    /**
-     * Retrieves all fields in the document as an `Object`. Returns `undefined` if
-     * the document doesn't exist.
-     *
-     * By default, `serverTimestamp()` values that have not yet been
-     * set to their final value will be returned as `null`. You can override
-     * this by passing an options object.
-     *
-     * @param options - An options object to configure how data is retrieved from
-     * the snapshot (for example the desired behavior for server timestamps that
-     * have not yet been set to their final value).
-     * @returns An `Object` containing all fields in the document or `undefined` if
-     * the document doesn't exist.
-     */
-    data(options = {}) {
-        if (!this._document) {
-            return undefined;
-        }
-        else if (this._converter) {
-            // We only want to use the converter and create a new DocumentSnapshot
-            // if a converter has been provided.
-            const snapshot = new QueryDocumentSnapshot(this._firestore, this._userDataWriter, this._key, this._document, this.metadata, 
-            /* converter= */ null);
-            return this._converter.fromFirestore(snapshot, options);
-        }
-        else {
-            return this._userDataWriter.convertValue(this._document.data.value, options.serverTimestamps);
-        }
+    return query;
+}
+class QueryFilterConstraint extends QueryConstraint {
+    constructor(_field, _op, _value) {
+        super();
+        this._field = _field;
+        this._op = _op;
+        this._value = _value;
+        this.type = 'where';
     }
-    /**
-     * Retrieves the field specified by `fieldPath`. Returns `undefined` if the
-     * document or field doesn't exist.
-     *
-     * By default, a `serverTimestamp()` that has not yet been set to
-     * its final value will be returned as `null`. You can override this by
-     * passing an options object.
-     *
-     * @param fieldPath - The path (for example 'foo' or 'foo.bar') to a specific
-     * field.
-     * @param options - An options object to configure how the field is retrieved
-     * from the snapshot (for example the desired behavior for server timestamps
-     * that have not yet been set to their final value).
-     * @returns The data at the specified field location or undefined if no such
-     * field exists in the document.
-     */
-    // We are using `any` here to avoid an explicit cast by our users.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    get(fieldPath, options = {}) {
-        if (this._document) {
-            const value = this._document.data.field(fieldPathFromArgument('DocumentSnapshot.get', fieldPath));
-            if (value !== null) {
-                return this._userDataWriter.convertValue(value, options.serverTimestamps);
-            }
-        }
-        return undefined;
+    _apply(query) {
+        const reader = newUserDataReader(query.firestore);
+        const filter = newQueryFilter(query._query, 'where', reader, query.firestore._databaseId, this._field, this._op, this._value);
+        return new Query(query.firestore, query.converter, queryWithAddedFilter(query._query, filter));
     }
 }
 /**
- * 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.
+ * Creates a {@link QueryConstraint} that enforces that documents must contain the
+ * specified field and that the value should satisfy the relation constraint
+ * provided.
  *
- * 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'.
+ * @param fieldPath - The path to compare
+ * @param opStr - The operation string (e.g "&lt;", "&lt;=", "==", "&lt;",
+ *   "&lt;=", "!=").
+ * @param value - The value for comparison
+ * @returns The created {@link Query}.
  */
-class QueryDocumentSnapshot extends DocumentSnapshot {
-    /**
-     * Retrieves all fields in the document as an `Object`.
-     *
-     * By default, `serverTimestamp()` values that have not yet been
-     * set to their final value will be returned as `null`. You can override
-     * this by passing an options object.
-     *
-     * @override
-     * @param options - An options object to configure how data is retrieved from
-     * the snapshot (for example the desired behavior for server timestamps that
-     * have not yet been set to their final value).
-     * @returns An `Object` containing all fields in the document.
-     */
-    data(options = {}) {
-        return super.data(options);
+function where(fieldPath, opStr, value) {
+    const op = opStr;
+    const field = fieldPathFromArgument('where', fieldPath);
+    return new QueryFilterConstraint(field, op, value);
+}
+class QueryOrderByConstraint extends QueryConstraint {
+    constructor(_field, _direction) {
+        super();
+        this._field = _field;
+        this._direction = _direction;
+        this.type = 'orderBy';
+    }
+    _apply(query) {
+        const orderBy = newQueryOrderBy(query._query, this._field, this._direction);
+        return new Query(query.firestore, query.converter, queryWithAddedOrderBy(query._query, orderBy));
     }
 }
 /**
- * A `QuerySnapshot` contains zero or more `DocumentSnapshot` objects
- * representing the results of a query. The documents can be accessed as an
- * array via the `docs` property or enumerated using the `forEach` method. The
- * number of documents can be determined via the `empty` and `size`
- * properties.
- */
-class QuerySnapshot {
-    /** @hideconstructor */
-    constructor(_firestore, _userDataWriter, query, _snapshot) {
-        this._firestore = _firestore;
-        this._userDataWriter = _userDataWriter;
-        this._snapshot = _snapshot;
-        this.metadata = new SnapshotMetadata(_snapshot.hasPendingWrites, _snapshot.fromCache);
-        this.query = query;
-    }
-    /** An array of all the documents in the `QuerySnapshot`. */
-    get docs() {
-        const result = [];
-        this.forEach(doc => result.push(doc));
-        return result;
-    }
-    /** The number of documents in the `QuerySnapshot`. */
-    get size() {
-        return this._snapshot.docs.size;
-    }
-    /** True if there are no documents in the `QuerySnapshot`. */
-    get empty() {
-        return this.size === 0;
-    }
-    /**
-     * Enumerates all of the documents in the `QuerySnapshot`.
-     *
-     * @param callback - A callback to be called with a `QueryDocumentSnapshot` for
-     * each document in the snapshot.
-     * @param thisArg - The `this` binding for the callback.
-     */
-    forEach(callback, thisArg) {
-        this._snapshot.docs.forEach(doc => {
-            callback.call(thisArg, new QueryDocumentSnapshot(this._firestore, this._userDataWriter, doc.key, doc, new SnapshotMetadata(this._snapshot.mutatedKeys.has(doc.key), this._snapshot.fromCache), this.query.converter));
-        });
-    }
-    /**
-     * 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.
-     *
-     * @param options - `SnapshotListenOptions` that control whether metadata-only
-     * changes (i.e. only `DocumentSnapshot.metadata` changed) should trigger
-     * snapshot events.
-     */
-    docChanges(options = {}) {
-        const includeMetadataChanges = !!options.includeMetadataChanges;
-        if (includeMetadataChanges && this._snapshot.excludesMetadataChanges) {
-            throw new FirestoreError(Code.INVALID_ARGUMENT, 'To include metadata changes with your document changes, you must ' +
-                'also pass { includeMetadataChanges:true } to onSnapshot().');
-        }
-        if (!this._cachedChanges ||
-            this._cachedChangesIncludeMetadataChanges !== includeMetadataChanges) {
-            this._cachedChanges = changesFromSnapshot(this, includeMetadataChanges);
-            this._cachedChangesIncludeMetadataChanges = includeMetadataChanges;
-        }
-        return this._cachedChanges;
-    }
-}
-/** Calculates the array of `DocumentChange`s for a given `ViewSnapshot`. */
-function changesFromSnapshot(querySnapshot, includeMetadataChanges) {
-    if (querySnapshot._snapshot.oldDocs.isEmpty()) {
-        let index = 0;
-        return querySnapshot._snapshot.docChanges.map(change => {
-            const doc = new QueryDocumentSnapshot(querySnapshot._firestore, querySnapshot._userDataWriter, change.doc.key, change.doc, new SnapshotMetadata(querySnapshot._snapshot.mutatedKeys.has(change.doc.key), querySnapshot._snapshot.fromCache), querySnapshot.query.converter);
-            return {
-                type: 'added',
-                doc,
-                oldIndex: -1,
-                newIndex: index++
-            };
-        });
-    }
-    else {
-        // A `DocumentSet` that is updated incrementally as changes are applied to use
-        // to lookup the index of a document.
-        let indexTracker = querySnapshot._snapshot.oldDocs;
-        return querySnapshot._snapshot.docChanges
-            .filter(change => includeMetadataChanges || change.type !== 3 /* Metadata */)
-            .map(change => {
-            const doc = new QueryDocumentSnapshot(querySnapshot._firestore, querySnapshot._userDataWriter, change.doc.key, change.doc, new SnapshotMetadata(querySnapshot._snapshot.mutatedKeys.has(change.doc.key), querySnapshot._snapshot.fromCache), querySnapshot.query.converter);
-            let oldIndex = -1;
-            let newIndex = -1;
-            if (change.type !== 0 /* Added */) {
-                oldIndex = indexTracker.indexOf(change.doc.key);
-                indexTracker = indexTracker.delete(change.doc.key);
-            }
-            if (change.type !== 1 /* Removed */) {
-                indexTracker = indexTracker.add(change.doc);
-                newIndex = indexTracker.indexOf(change.doc.key);
-            }
-            return {
-                type: resultChangeType(change.type),
-                doc,
-                oldIndex,
-                newIndex
-            };
-        });
-    }
-}
-function resultChangeType(type) {
-    switch (type) {
-        case 0 /* Added */:
-            return 'added';
-        case 2 /* Modified */:
-        case 3 /* Metadata */:
-            return 'modified';
-        case 1 /* Removed */:
-            return 'removed';
-        default:
-            return fail();
-    }
-}
-// TODO(firestoreexp): Add tests for snapshotEqual with different snapshot
-// metadata
-/**
- * Returns true if the provided snapshots are equal.
- *
- * @param left - A snapshot to compare.
- * @param right - A snapshot to compare.
- * @returns true if the snapshots are equal.
- */
-function snapshotEqual(left, right) {
-    if (left instanceof DocumentSnapshot && right instanceof DocumentSnapshot) {
-        return (left._firestore === right._firestore &&
-            left._key.isEqual(right._key) &&
-            (left._document === null
-                ? right._document === null
-                : left._document.isEqual(right._document)) &&
-            left._converter === right._converter);
-    }
-    else if (left instanceof QuerySnapshot && right instanceof QuerySnapshot) {
-        return (left._firestore === right._firestore &&
-            queryEqual(left.query, right.query) &&
-            left.metadata.isEqual(right.metadata) &&
-            left._snapshot.isEqual(right._snapshot));
-    }
-    return false;
-}
-
-/**
- * @license
- * 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.
- */
-function validateHasExplicitOrderByForLimitToLast(query) {
-    if (query.limitType === "L" /* Last */ &&
-        query.explicitOrderBy.length === 0) {
-        throw new FirestoreError(Code.UNIMPLEMENTED, 'limitToLast() queries require specifying at least one orderBy() clause');
-    }
-}
-/**
- * A `QueryConstraint` is used to narrow the set of documents returned by a
- * Firestore query. `QueryConstraint`s are created by invoking {@link where},
- * {@link orderBy}, {@link (startAt:1)}, {@link (startAfter:1)}, {@link
- * endBefore:1}, {@link (endAt:1)}, {@link limit} or {@link limitToLast} and
- * can then be passed to {@link query} to create a new query instance that
- * also contains this `QueryConstraint`.
- */
-class QueryConstraint {
-}
-/**
- * Creates a new immutable instance of {@link Query} that is extended to also include
- * additional query constraints.
- *
- * @param query - The {@link Query} instance to use as a base for the new constraints.
- * @param queryConstraints - The list of {@link QueryConstraint}s to apply.
- * @throws if any of the provided query constraints cannot be combined with the
- * existing or new constraints.
- */
-function query(query, ...queryConstraints) {
-    for (const constraint of queryConstraints) {
-        query = constraint._apply(query);
-    }
-    return query;
-}
-class QueryFilterConstraint extends QueryConstraint {
-    constructor(_field, _op, _value) {
-        super();
-        this._field = _field;
-        this._op = _op;
-        this._value = _value;
-        this.type = 'where';
-    }
-    _apply(query) {
-        const reader = newUserDataReader(query.firestore);
-        const filter = newQueryFilter(query._query, 'where', reader, query.firestore._databaseId, this._field, this._op, this._value);
-        return new Query(query.firestore, query.converter, queryWithAddedFilter(query._query, filter));
-    }
-}
-/**
- * Creates a {@link QueryConstraint} that enforces that documents must contain the
- * specified field and that the value should satisfy the relation constraint
- * provided.
- *
- * @param fieldPath - The path to compare
- * @param opStr - The operation string (e.g "&lt;", "&lt;=", "==", "&lt;",
- *   "&lt;=", "!=").
- * @param value - The value for comparison
- * @returns The created {@link Query}.
- */
-function where(fieldPath, opStr, value) {
-    const op = opStr;
-    const field = fieldPathFromArgument('where', fieldPath);
-    return new QueryFilterConstraint(field, op, value);
-}
-class QueryOrderByConstraint extends QueryConstraint {
-    constructor(_field, _direction) {
-        super();
-        this._field = _field;
-        this._direction = _direction;
-        this.type = 'orderBy';
-    }
-    _apply(query) {
-        const orderBy = newQueryOrderBy(query._query, this._field, this._direction);
-        return new Query(query.firestore, query.converter, queryWithAddedOrderBy(query._query, orderBy));
-    }
-}
-/**
- * Creates a {@link QueryConstraint} that sorts the query result by the
- * specified field, optionally in descending order instead of ascending.
- *
- * @param fieldPath - The field to sort by.
- * @param directionStr - Optional direction to sort by ('asc' or 'desc'). If
- * not specified, order will be ascending.
- * @returns The created {@link Query}.
+ * Creates a {@link QueryConstraint} that sorts the query result by the
+ * specified field, optionally in descending order instead of ascending.
+ *
+ * @param fieldPath - The field to sort by.
+ * @param directionStr - Optional direction to sort by ('asc' or 'desc'). If
+ * not specified, order will be ascending.
+ * @returns The created {@link Query}.
  */
 function orderBy(fieldPath, directionStr = 'asc') {
     const direction = directionStr;
@@ -28445,31 +28491,6 @@ function validateOrderByAndInequalityMatch(baseQuery, inequality, orderBy) {
     }
 }
 
-/**
- * @license
- * Copyright 2022 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.
- */
-const DEFAULT_TRANSACTION_OPTIONS = {
-    maxAttempts: 5
-};
-function validateTransactionOptions(options) {
-    if (options.maxAttempts < 1) {
-        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Max attempts must be at least 1');
-    }
-}
-
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -28644,221 +28665,276 @@ class LiteUserDataWriter extends AbstractUserDataWriter {
  * limitations under the License.
  */
 /**
- * A write batch, used to perform multiple writes as a single atomic unit.
- *
- * A `WriteBatch` object can be acquired by calling {@link writeBatch}. It
- * provides methods for adding writes to the write batch. None of the writes
- * will be committed (or visible locally) until {@link WriteBatch.commit} is
- * called.
+ * Metadata about a snapshot, describing the state of the snapshot.
  */
-class WriteBatch {
+class SnapshotMetadata {
     /** @hideconstructor */
-    constructor(_firestore, _commitHandler) {
-        this._firestore = _firestore;
-        this._commitHandler = _commitHandler;
-        this._mutations = [];
-        this._committed = false;
-        this._dataReader = newUserDataReader(_firestore);
+    constructor(hasPendingWrites, fromCache) {
+        this.hasPendingWrites = hasPendingWrites;
+        this.fromCache = fromCache;
     }
-    set(documentRef, data, options) {
-        this._verifyNotCommitted();
-        const ref = validateReference(documentRef, this._firestore);
-        const convertedValue = applyFirestoreDataConverter(ref.converter, data, options);
-        const parsed = parseSetData(this._dataReader, 'WriteBatch.set', ref._key, convertedValue, ref.converter !== null, options);
-        this._mutations.push(parsed.toMutation(ref._key, Precondition.none()));
-        return this;
+    /**
+     * Returns true if this `SnapshotMetadata` is equal to the provided one.
+     *
+     * @param other - The `SnapshotMetadata` to compare against.
+     * @returns true if this `SnapshotMetadata` is equal to the provided one.
+     */
+    isEqual(other) {
+        return (this.hasPendingWrites === other.hasPendingWrites &&
+            this.fromCache === other.fromCache);
     }
-    update(documentRef, fieldOrUpdateData, value, ...moreFieldsAndValues) {
-        this._verifyNotCommitted();
-        const ref = validateReference(documentRef, this._firestore);
-        // For Compat types, we have to "extract" the underlying types before
-        // performing validation.
-        fieldOrUpdateData = util$1.getModularInstance(fieldOrUpdateData);
-        let parsed;
-        if (typeof fieldOrUpdateData === 'string' ||
-            fieldOrUpdateData instanceof FieldPath) {
-            parsed = parseUpdateVarargs(this._dataReader, 'WriteBatch.update', ref._key, fieldOrUpdateData, value, moreFieldsAndValues);
-        }
-        else {
-            parsed = parseUpdateData(this._dataReader, 'WriteBatch.update', ref._key, fieldOrUpdateData);
-        }
-        this._mutations.push(parsed.toMutation(ref._key, Precondition.exists(true)));
-        return this;
+}
+/**
+ * A `DocumentSnapshot` contains data read from a document in your Firestore
+ * database. The data can be extracted with `.data()` or `.get(<field>)` to
+ * get a specific field.
+ *
+ * For a `DocumentSnapshot` that points to a non-existing document, any data
+ * access will return 'undefined'. You can use the `exists()` method to
+ * explicitly verify a document's existence.
+ */
+class DocumentSnapshot extends DocumentSnapshot$1 {
+    /** @hideconstructor protected */
+    constructor(_firestore, userDataWriter, key, document, metadata, converter) {
+        super(_firestore, userDataWriter, key, document, converter);
+        this._firestore = _firestore;
+        this._firestoreImpl = _firestore;
+        this.metadata = metadata;
     }
     /**
-     * Deletes the document referred to by the provided {@link DocumentReference}.
-     *
-     * @param documentRef - A reference to the document to be deleted.
-     * @returns This `WriteBatch` instance. Used for chaining method calls.
+     * Returns whether or not the data exists. True if the document exists.
      */
-    delete(documentRef) {
-        this._verifyNotCommitted();
-        const ref = validateReference(documentRef, this._firestore);
-        this._mutations = this._mutations.concat(new DeleteMutation(ref._key, Precondition.none()));
-        return this;
+    exists() {
+        return super.exists();
     }
     /**
-     * Commits all of the writes in this write batch as a single atomic unit.
+     * Retrieves all fields in the document as an `Object`. Returns `undefined` if
+     * the document doesn't exist.
      *
-     * The result of these writes will only be reflected in document reads that
-     * occur after the returned promise resolves. If the client is offline, the
-     * write fails. If you would like to see local modifications or buffer writes
-     * until the client is online, use the full Firestore SDK.
+     * By default, `serverTimestamp()` values that have not yet been
+     * set to their final value will be returned as `null`. You can override
+     * this by passing an options object.
      *
-     * @returns A `Promise` resolved once all of the writes in the batch have been
-     * successfully written to the backend as an atomic unit (note that it won't
-     * resolve while you're offline).
+     * @param options - An options object to configure how data is retrieved from
+     * the snapshot (for example the desired behavior for server timestamps that
+     * have not yet been set to their final value).
+     * @returns An `Object` containing all fields in the document or `undefined` if
+     * the document doesn't exist.
      */
-    commit() {
-        this._verifyNotCommitted();
-        this._committed = true;
-        if (this._mutations.length > 0) {
-            return this._commitHandler(this._mutations);
+    data(options = {}) {
+        if (!this._document) {
+            return undefined;
+        }
+        else if (this._converter) {
+            // We only want to use the converter and create a new DocumentSnapshot
+            // if a converter has been provided.
+            const snapshot = new QueryDocumentSnapshot(this._firestore, this._userDataWriter, this._key, this._document, this.metadata, 
+            /* converter= */ null);
+            return this._converter.fromFirestore(snapshot, options);
+        }
+        else {
+            return this._userDataWriter.convertValue(this._document.data.value, options.serverTimestamps);
         }
-        return Promise.resolve();
     }
-    _verifyNotCommitted() {
-        if (this._committed) {
-            throw new FirestoreError(Code.FAILED_PRECONDITION, 'A write batch can no longer be used after commit() ' +
-                'has been called.');
+    /**
+     * Retrieves the field specified by `fieldPath`. Returns `undefined` if the
+     * document or field doesn't exist.
+     *
+     * By default, a `serverTimestamp()` that has not yet been set to
+     * its final value will be returned as `null`. You can override this by
+     * passing an options object.
+     *
+     * @param fieldPath - The path (for example 'foo' or 'foo.bar') to a specific
+     * field.
+     * @param options - An options object to configure how the field is retrieved
+     * from the snapshot (for example the desired behavior for server timestamps
+     * that have not yet been set to their final value).
+     * @returns The data at the specified field location or undefined if no such
+     * field exists in the document.
+     */
+    // We are using `any` here to avoid an explicit cast by our users.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    get(fieldPath, options = {}) {
+        if (this._document) {
+            const value = this._document.data.field(fieldPathFromArgument('DocumentSnapshot.get', fieldPath));
+            if (value !== null) {
+                return this._userDataWriter.convertValue(value, options.serverTimestamps);
+            }
         }
+        return undefined;
     }
 }
-function validateReference(documentRef, firestore) {
-    documentRef = util$1.getModularInstance(documentRef);
-    if (documentRef.firestore !== firestore) {
-        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Provided document reference is from a different Firestore instance.');
-    }
-    else {
-        return documentRef;
-    }
-}
-
 /**
- * @license
- * 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
+ * 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.
  *
- * 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.
+ * 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'.
  */
-// TODO(mrschmidt) Consider using `BaseTransaction` as the base class in the
-// legacy SDK.
+class QueryDocumentSnapshot extends DocumentSnapshot {
+    /**
+     * Retrieves all fields in the document as an `Object`.
+     *
+     * By default, `serverTimestamp()` values that have not yet been
+     * set to their final value will be returned as `null`. You can override
+     * this by passing an options object.
+     *
+     * @override
+     * @param options - An options object to configure how data is retrieved from
+     * the snapshot (for example the desired behavior for server timestamps that
+     * have not yet been set to their final value).
+     * @returns An `Object` containing all fields in the document.
+     */
+    data(options = {}) {
+        return super.data(options);
+    }
+}
 /**
- * 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
- * {@link runTransaction}.
+ * A `QuerySnapshot` contains zero or more `DocumentSnapshot` objects
+ * representing the results of a query. The documents can be accessed as an
+ * array via the `docs` property or enumerated using the `forEach` method. The
+ * number of documents can be determined via the `empty` and `size`
+ * properties.
  */
-class Transaction$1 {
+class QuerySnapshot {
     /** @hideconstructor */
-    constructor(_firestore, _transaction) {
+    constructor(_firestore, _userDataWriter, query, _snapshot) {
         this._firestore = _firestore;
-        this._transaction = _transaction;
-        this._dataReader = newUserDataReader(_firestore);
+        this._userDataWriter = _userDataWriter;
+        this._snapshot = _snapshot;
+        this.metadata = new SnapshotMetadata(_snapshot.hasPendingWrites, _snapshot.fromCache);
+        this.query = query;
+    }
+    /** An array of all the documents in the `QuerySnapshot`. */
+    get docs() {
+        const result = [];
+        this.forEach(doc => result.push(doc));
+        return result;
+    }
+    /** The number of documents in the `QuerySnapshot`. */
+    get size() {
+        return this._snapshot.docs.size;
+    }
+    /** True if there are no documents in the `QuerySnapshot`. */
+    get empty() {
+        return this.size === 0;
     }
     /**
-     * Reads the document referenced by the provided {@link DocumentReference}.
+     * Enumerates all of the documents in the `QuerySnapshot`.
      *
-     * @param documentRef - A reference to the document to be read.
-     * @returns A `DocumentSnapshot` with the read data.
+     * @param callback - A callback to be called with a `QueryDocumentSnapshot` for
+     * each document in the snapshot.
+     * @param thisArg - The `this` binding for the callback.
      */
-    get(documentRef) {
-        const ref = validateReference(documentRef, this._firestore);
-        const userDataWriter = new LiteUserDataWriter(this._firestore);
-        return this._transaction.lookup([ref._key]).then(docs => {
-            if (!docs || docs.length !== 1) {
-                return fail();
-            }
-            const doc = docs[0];
-            if (doc.isFoundDocument()) {
-                return new DocumentSnapshot$1(this._firestore, userDataWriter, doc.key, doc, ref.converter);
-            }
-            else if (doc.isNoDocument()) {
-                return new DocumentSnapshot$1(this._firestore, userDataWriter, ref._key, null, ref.converter);
-            }
-            else {
-                throw fail();
-            }
+    forEach(callback, thisArg) {
+        this._snapshot.docs.forEach(doc => {
+            callback.call(thisArg, new QueryDocumentSnapshot(this._firestore, this._userDataWriter, doc.key, doc, new SnapshotMetadata(this._snapshot.mutatedKeys.has(doc.key), this._snapshot.fromCache), this.query.converter));
         });
     }
-    set(documentRef, value, options) {
-        const ref = validateReference(documentRef, this._firestore);
-        const convertedValue = applyFirestoreDataConverter(ref.converter, value, options);
-        const parsed = parseSetData(this._dataReader, 'Transaction.set', ref._key, convertedValue, ref.converter !== null, options);
-        this._transaction.set(ref._key, parsed);
-        return this;
-    }
-    update(documentRef, fieldOrUpdateData, value, ...moreFieldsAndValues) {
-        const ref = validateReference(documentRef, this._firestore);
-        // For Compat types, we have to "extract" the underlying types before
-        // performing validation.
-        fieldOrUpdateData = util$1.getModularInstance(fieldOrUpdateData);
-        let parsed;
-        if (typeof fieldOrUpdateData === 'string' ||
-            fieldOrUpdateData instanceof FieldPath) {
-            parsed = parseUpdateVarargs(this._dataReader, 'Transaction.update', ref._key, fieldOrUpdateData, value, moreFieldsAndValues);
-        }
-        else {
-            parsed = parseUpdateData(this._dataReader, 'Transaction.update', ref._key, fieldOrUpdateData);
-        }
-        this._transaction.update(ref._key, parsed);
-        return this;
-    }
     /**
-     * Deletes the document referred to by the provided {@link DocumentReference}.
+     * 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.
      *
-     * @param documentRef - A reference to the document to be deleted.
-     * @returns This `Transaction` instance. Used for chaining method calls.
+     * @param options - `SnapshotListenOptions` that control whether metadata-only
+     * changes (i.e. only `DocumentSnapshot.metadata` changed) should trigger
+     * snapshot events.
      */
-    delete(documentRef) {
-        const ref = validateReference(documentRef, this._firestore);
-        this._transaction.delete(ref._key);
-        return this;
+    docChanges(options = {}) {
+        const includeMetadataChanges = !!options.includeMetadataChanges;
+        if (includeMetadataChanges && this._snapshot.excludesMetadataChanges) {
+            throw new FirestoreError(Code.INVALID_ARGUMENT, 'To include metadata changes with your document changes, you must ' +
+                'also pass { includeMetadataChanges:true } to onSnapshot().');
+        }
+        if (!this._cachedChanges ||
+            this._cachedChangesIncludeMetadataChanges !== includeMetadataChanges) {
+            this._cachedChanges = changesFromSnapshot(this, includeMetadataChanges);
+            this._cachedChangesIncludeMetadataChanges = includeMetadataChanges;
+        }
+        return this._cachedChanges;
+    }
+}
+/** Calculates the array of `DocumentChange`s for a given `ViewSnapshot`. */
+function changesFromSnapshot(querySnapshot, includeMetadataChanges) {
+    if (querySnapshot._snapshot.oldDocs.isEmpty()) {
+        let index = 0;
+        return querySnapshot._snapshot.docChanges.map(change => {
+            const doc = new QueryDocumentSnapshot(querySnapshot._firestore, querySnapshot._userDataWriter, change.doc.key, change.doc, new SnapshotMetadata(querySnapshot._snapshot.mutatedKeys.has(change.doc.key), querySnapshot._snapshot.fromCache), querySnapshot.query.converter);
+            return {
+                type: 'added',
+                doc,
+                oldIndex: -1,
+                newIndex: index++
+            };
+        });
+    }
+    else {
+        // A `DocumentSet` that is updated incrementally as changes are applied to use
+        // to lookup the index of a document.
+        let indexTracker = querySnapshot._snapshot.oldDocs;
+        return querySnapshot._snapshot.docChanges
+            .filter(change => includeMetadataChanges || change.type !== 3 /* Metadata */)
+            .map(change => {
+            const doc = new QueryDocumentSnapshot(querySnapshot._firestore, querySnapshot._userDataWriter, change.doc.key, change.doc, new SnapshotMetadata(querySnapshot._snapshot.mutatedKeys.has(change.doc.key), querySnapshot._snapshot.fromCache), querySnapshot.query.converter);
+            let oldIndex = -1;
+            let newIndex = -1;
+            if (change.type !== 0 /* Added */) {
+                oldIndex = indexTracker.indexOf(change.doc.key);
+                indexTracker = indexTracker.delete(change.doc.key);
+            }
+            if (change.type !== 1 /* Removed */) {
+                indexTracker = indexTracker.add(change.doc);
+                newIndex = indexTracker.indexOf(change.doc.key);
+            }
+            return {
+                type: resultChangeType(change.type),
+                doc,
+                oldIndex,
+                newIndex
+            };
+        });
+    }
+}
+function resultChangeType(type) {
+    switch (type) {
+        case 0 /* Added */:
+            return 'added';
+        case 2 /* Modified */:
+        case 3 /* Metadata */:
+            return 'modified';
+        case 1 /* Removed */:
+            return 'removed';
+        default:
+            return fail();
     }
-}
-
-/**
- * @license
- * Copyright 2017 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.
- */
-function isPartialObserver(obj) {
-    return implementsAnyMethods(obj, ['next', 'error', 'complete']);
 }
+// TODO(firestoreexp): Add tests for snapshotEqual with different snapshot
+// metadata
 /**
- * Returns true if obj is an object and contains at least one of the specified
- * methods.
+ * Returns true if the provided snapshots are equal.
+ *
+ * @param left - A snapshot to compare.
+ * @param right - A snapshot to compare.
+ * @returns true if the snapshots are equal.
  */
-function implementsAnyMethods(obj, methods) {
-    if (typeof obj !== 'object' || obj === null) {
-        return false;
+function snapshotEqual(left, right) {
+    if (left instanceof DocumentSnapshot && right instanceof DocumentSnapshot) {
+        return (left._firestore === right._firestore &&
+            left._key.isEqual(right._key) &&
+            (left._document === null
+                ? right._document === null
+                : left._document.isEqual(right._document)) &&
+            left._converter === right._converter);
     }
-    const object = obj;
-    for (const method of methods) {
-        if (method in object && typeof object[method] === 'function') {
-            return true;
-        }
+    else if (left instanceof QuerySnapshot && right instanceof QuerySnapshot) {
+        return (left._firestore === right._firestore &&
+            queryEqual(left.query, right.query) &&
+            left.metadata.isEqual(right.metadata) &&
+            left._snapshot.isEqual(right._snapshot));
     }
     return false;
 }
@@ -29127,6 +29203,307 @@ function convertToDocSnapshot(firestore, ref, snapshot) {
     return new DocumentSnapshot(firestore, userDataWriter, ref._key, doc, new SnapshotMetadata(snapshot.hasPendingWrites, snapshot.fromCache), ref.converter);
 }
 
+/**
+ * @license
+ * Copyright 2022 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.
+ */
+/**
+ * Compares two `AggregateQuerySnapshot` instances for equality.
+ *
+ * Two `AggregateQuerySnapshot` instances are considered "equal" if they have
+ * underlying queries that compare equal, and the same data.
+ *
+ * @param left - The first `AggregateQuerySnapshot` to compare.
+ * @param right - The second `AggregateQuerySnapshot` to compare.
+ *
+ * @returns `true` if the objects are "equal", as defined above, or `false`
+ * otherwise.
+ */
+function aggregateQuerySnapshotEqual(left, right) {
+    return (queryEqual(left.query, right.query) && util$1.deepEqual(left.data(), right.data()));
+}
+
+/**
+ * @license
+ * Copyright 2022 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.
+ */
+/**
+ * Calculates the number of documents in the result set of the given query,
+ * without actually downloading the documents.
+ *
+ * Using this function to count the documents is efficient because only the
+ * final count, not the documents' data, is downloaded. This function can even
+ * count the documents if the result set would be prohibitively large to
+ * download entirely (e.g. thousands of documents).
+ *
+ * The result received from the server is presented, unaltered, without
+ * considering any local state. That is, documents in the local cache are not
+ * taken into consideration, neither are local modifications not yet
+ * synchronized with the server. Previously-downloaded results, if any, are not
+ * used: every request using this source necessarily involves a round trip to
+ * the server.
+ *
+ * @param query - The query whose result set size to calculate.
+ * @returns A Promise that will be resolved with the count; the count can be
+ * retrieved from `snapshot.data().count`, where `snapshot` is the
+ * `AggregateQuerySnapshot` to which the returned Promise resolves.
+ */
+function getCountFromServer(query) {
+    const firestore = cast(query.firestore, Firestore);
+    const client = ensureFirestoreConfigured(firestore);
+    const userDataWriter = new ExpUserDataWriter(firestore);
+    return firestoreClientRunCountQuery(client, query, userDataWriter);
+}
+
+/**
+ * @license
+ * Copyright 2022 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.
+ */
+const DEFAULT_TRANSACTION_OPTIONS = {
+    maxAttempts: 5
+};
+function validateTransactionOptions(options) {
+    if (options.maxAttempts < 1) {
+        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Max attempts must be at least 1');
+    }
+}
+
+/**
+ * @license
+ * 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.
+ */
+/**
+ * A write batch, used to perform multiple writes as a single atomic unit.
+ *
+ * A `WriteBatch` object can be acquired by calling {@link writeBatch}. It
+ * provides methods for adding writes to the write batch. None of the writes
+ * will be committed (or visible locally) until {@link WriteBatch.commit} is
+ * called.
+ */
+class WriteBatch {
+    /** @hideconstructor */
+    constructor(_firestore, _commitHandler) {
+        this._firestore = _firestore;
+        this._commitHandler = _commitHandler;
+        this._mutations = [];
+        this._committed = false;
+        this._dataReader = newUserDataReader(_firestore);
+    }
+    set(documentRef, data, options) {
+        this._verifyNotCommitted();
+        const ref = validateReference(documentRef, this._firestore);
+        const convertedValue = applyFirestoreDataConverter(ref.converter, data, options);
+        const parsed = parseSetData(this._dataReader, 'WriteBatch.set', ref._key, convertedValue, ref.converter !== null, options);
+        this._mutations.push(parsed.toMutation(ref._key, Precondition.none()));
+        return this;
+    }
+    update(documentRef, fieldOrUpdateData, value, ...moreFieldsAndValues) {
+        this._verifyNotCommitted();
+        const ref = validateReference(documentRef, this._firestore);
+        // For Compat types, we have to "extract" the underlying types before
+        // performing validation.
+        fieldOrUpdateData = util$1.getModularInstance(fieldOrUpdateData);
+        let parsed;
+        if (typeof fieldOrUpdateData === 'string' ||
+            fieldOrUpdateData instanceof FieldPath) {
+            parsed = parseUpdateVarargs(this._dataReader, 'WriteBatch.update', ref._key, fieldOrUpdateData, value, moreFieldsAndValues);
+        }
+        else {
+            parsed = parseUpdateData(this._dataReader, 'WriteBatch.update', ref._key, fieldOrUpdateData);
+        }
+        this._mutations.push(parsed.toMutation(ref._key, Precondition.exists(true)));
+        return this;
+    }
+    /**
+     * Deletes the document referred to by the provided {@link DocumentReference}.
+     *
+     * @param documentRef - A reference to the document to be deleted.
+     * @returns This `WriteBatch` instance. Used for chaining method calls.
+     */
+    delete(documentRef) {
+        this._verifyNotCommitted();
+        const ref = validateReference(documentRef, this._firestore);
+        this._mutations = this._mutations.concat(new DeleteMutation(ref._key, Precondition.none()));
+        return this;
+    }
+    /**
+     * Commits all of the writes in this write batch as a single atomic unit.
+     *
+     * The result of these writes will only be reflected in document reads that
+     * occur after the returned promise resolves. If the client is offline, the
+     * write fails. If you would like to see local modifications or buffer writes
+     * until the client is online, use the full Firestore SDK.
+     *
+     * @returns A `Promise` resolved once all of the writes in the batch have been
+     * successfully written to the backend as an atomic unit (note that it won't
+     * resolve while you're offline).
+     */
+    commit() {
+        this._verifyNotCommitted();
+        this._committed = true;
+        if (this._mutations.length > 0) {
+            return this._commitHandler(this._mutations);
+        }
+        return Promise.resolve();
+    }
+    _verifyNotCommitted() {
+        if (this._committed) {
+            throw new FirestoreError(Code.FAILED_PRECONDITION, 'A write batch can no longer be used after commit() ' +
+                'has been called.');
+        }
+    }
+}
+function validateReference(documentRef, firestore) {
+    documentRef = util$1.getModularInstance(documentRef);
+    if (documentRef.firestore !== firestore) {
+        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Provided document reference is from a different Firestore instance.');
+    }
+    else {
+        return documentRef;
+    }
+}
+
+/**
+ * @license
+ * 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.
+ */
+// TODO(mrschmidt) Consider using `BaseTransaction` as the base class in the
+// legacy SDK.
+/**
+ * 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
+ * {@link runTransaction}.
+ */
+class Transaction$1 {
+    /** @hideconstructor */
+    constructor(_firestore, _transaction) {
+        this._firestore = _firestore;
+        this._transaction = _transaction;
+        this._dataReader = newUserDataReader(_firestore);
+    }
+    /**
+     * Reads the document referenced by the provided {@link DocumentReference}.
+     *
+     * @param documentRef - A reference to the document to be read.
+     * @returns A `DocumentSnapshot` with the read data.
+     */
+    get(documentRef) {
+        const ref = validateReference(documentRef, this._firestore);
+        const userDataWriter = new LiteUserDataWriter(this._firestore);
+        return this._transaction.lookup([ref._key]).then(docs => {
+            if (!docs || docs.length !== 1) {
+                return fail();
+            }
+            const doc = docs[0];
+            if (doc.isFoundDocument()) {
+                return new DocumentSnapshot$1(this._firestore, userDataWriter, doc.key, doc, ref.converter);
+            }
+            else if (doc.isNoDocument()) {
+                return new DocumentSnapshot$1(this._firestore, userDataWriter, ref._key, null, ref.converter);
+            }
+            else {
+                throw fail();
+            }
+        });
+    }
+    set(documentRef, value, options) {
+        const ref = validateReference(documentRef, this._firestore);
+        const convertedValue = applyFirestoreDataConverter(ref.converter, value, options);
+        const parsed = parseSetData(this._dataReader, 'Transaction.set', ref._key, convertedValue, ref.converter !== null, options);
+        this._transaction.set(ref._key, parsed);
+        return this;
+    }
+    update(documentRef, fieldOrUpdateData, value, ...moreFieldsAndValues) {
+        const ref = validateReference(documentRef, this._firestore);
+        // For Compat types, we have to "extract" the underlying types before
+        // performing validation.
+        fieldOrUpdateData = util$1.getModularInstance(fieldOrUpdateData);
+        let parsed;
+        if (typeof fieldOrUpdateData === 'string' ||
+            fieldOrUpdateData instanceof FieldPath) {
+            parsed = parseUpdateVarargs(this._dataReader, 'Transaction.update', ref._key, fieldOrUpdateData, value, moreFieldsAndValues);
+        }
+        else {
+            parsed = parseUpdateData(this._dataReader, 'Transaction.update', ref._key, fieldOrUpdateData);
+        }
+        this._transaction.update(ref._key, parsed);
+        return this;
+    }
+    /**
+     * Deletes the document referred to by the provided {@link DocumentReference}.
+     *
+     * @param documentRef - A reference to the document to be deleted.
+     * @returns This `Transaction` instance. Used for chaining method calls.
+     */
+    delete(documentRef) {
+        const ref = validateReference(documentRef, this._firestore);
+        this._transaction.delete(ref._key);
+        return this;
+    }
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -29413,6 +29790,8 @@ function tryGetString(data, property) {
 registerFirestore('node');
 
 exports.AbstractUserDataWriter = AbstractUserDataWriter;
+exports.AggregateField = AggregateField;
+exports.AggregateQuerySnapshot = AggregateQuerySnapshot;
 exports.Bytes = Bytes;
 exports.CACHE_SIZE_UNLIMITED = CACHE_SIZE_UNLIMITED;
 exports.CollectionReference = CollectionReference;
@@ -29443,6 +29822,7 @@ exports._isBase64Available = isBase64Available;
 exports._logWarn = logWarn;
 exports._validateIsNotUsedTogether = validateIsNotUsedTogether;
 exports.addDoc = addDoc;
+exports.aggregateQuerySnapshotEqual = aggregateQuerySnapshotEqual;
 exports.arrayRemove = arrayRemove;
 exports.arrayUnion = arrayUnion;
 exports.clearIndexedDbPersistence = clearIndexedDbPersistence;
@@ -29461,6 +29841,7 @@ exports.endAt = endAt;
 exports.endBefore = endBefore;
 exports.ensureFirestoreConfigured = ensureFirestoreConfigured;
 exports.executeWrite = executeWrite;
+exports.getCountFromServer = getCountFromServer;
 exports.getDoc = getDoc;
 exports.getDocFromCache = getDocFromCache;
 exports.getDocFromServer = getDocFromServer;