@fleox-agent-crm/agentcrm 0.3.3 → 0.4.0

package/dist/agent/chunks/{sdk-CYgNyuoK.mjs → sdk-NYUHv7WG.mjs}

@@ -21,7 +21,7 @@ import require$$3$1 from "http";
 import require$$7 from "url";
 import require$$1$3 from "dns";
 import require$$0$7 from "zlib";
-import { D as DELETE_FIELD } from "./api-Dwb4xz1k.mjs";
+import { w as withChangeTracking, D as DELETE_FIELD, S as SERVER_TIMESTAMP, T as TS_FIELD, d as splitTs } from "./api-BEl_EKwf.mjs";
 var name$2 = "firebase";
 var version$3 = "11.10.0";
 /**
@@ -21713,6 +21713,11 @@ function estimateMapByteSize(mapValue) {
 function estimateArrayByteSize(arrayValue) {
   return (arrayValue.values || []).reduce((previousSize, value) => previousSize + estimateByteSize(value), 0);
 }
+function refValue(databaseId, key) {
+  return {
+    referenceValue: `projects/${databaseId.projectId}/databases/${databaseId.database}/documents/${key.path.canonicalString()}`
+  };
+}
 function isInteger(value) {
   return !!value && "integerValue" in value;
 }
@@ -22624,25 +22629,25 @@ function newQuery(path2, collectionGroup, explicitOrderBy, filters, limit, limit
 function newQueryForPath(path2) {
   return new QueryImpl(path2);
 }
-function asCollectionQueryAtPath(query, path2) {
+function asCollectionQueryAtPath(query2, path2) {
   return new QueryImpl(
     path2,
     /*collectionGroup=*/
     null,
-    query.explicitOrderBy.slice(),
-    query.filters.slice(),
-    query.limit,
-    query.limitType,
-    query.startAt,
-    query.endAt
+    query2.explicitOrderBy.slice(),
+    query2.filters.slice(),
+    query2.limit,
+    query2.limitType,
+    query2.startAt,
+    query2.endAt
   );
 }
-function queryMatchesAllDocuments(query) {
-  return query.filters.length === 0 && query.limit === null && query.startAt == null && query.endAt == null && (query.explicitOrderBy.length === 0 || query.explicitOrderBy.length === 1 && query.explicitOrderBy[0].field.isKeyField());
+function queryMatchesAllDocuments(query2) {
+  return query2.filters.length === 0 && query2.limit === null && query2.startAt == null && query2.endAt == null && (query2.explicitOrderBy.length === 0 || query2.explicitOrderBy.length === 1 && query2.explicitOrderBy[0].field.isKeyField());
 }
-function getInequalityFilterFields(query) {
+function getInequalityFilterFields(query2) {
   let result = new SortedSet(FieldPath$1.comparator);
-  query.filters.forEach((filter2) => {
+  query2.filters.forEach((filter2) => {
     const subFilters = filter2.getFlattenedFilters();
     subFilters.forEach((filter3) => {
       if (filter3.isInequality()) {
@@ -22652,14 +22657,14 @@ function getInequalityFilterFields(query) {
   });
   return result;
 }
-function isDocumentQuery$1(query) {
-  return DocumentKey.isDocumentKey(query.path) && query.collectionGroup === null && query.filters.length === 0;
+function isDocumentQuery$1(query2) {
+  return DocumentKey.isDocumentKey(query2.path) && query2.collectionGroup === null && query2.filters.length === 0;
 }
-function isCollectionGroupQuery(query) {
-  return query.collectionGroup !== null;
+function isCollectionGroupQuery(query2) {
+  return query2.collectionGroup !== null;
 }
-function queryNormalizedOrderBy(query) {
-  const queryImpl = debugCast(query);
+function queryNormalizedOrderBy(query2) {
+  const queryImpl = debugCast(query2);
   if (queryImpl.memoizedNormalizedOrderBy === null) {
     queryImpl.memoizedNormalizedOrderBy = [];
     const fieldsNormalized = /* @__PURE__ */ new Set();
@@ -22680,10 +22685,10 @@ function queryNormalizedOrderBy(query) {
   }
   return queryImpl.memoizedNormalizedOrderBy;
 }
-function queryToTarget(query) {
-  const queryImpl = debugCast(query);
+function queryToTarget(query2) {
+  const queryImpl = debugCast(query2);
   if (!queryImpl.memoizedTarget) {
-    queryImpl.memoizedTarget = _queryToTarget(queryImpl, queryNormalizedOrderBy(query));
+    queryImpl.memoizedTarget = _queryToTarget(queryImpl, queryNormalizedOrderBy(query2));
   }
   return queryImpl.memoizedTarget;
 }
@@ -22700,63 +22705,67 @@ function _queryToTarget(queryImpl, orderBys) {
     return newTarget(queryImpl.path, queryImpl.collectionGroup, orderBys, queryImpl.filters, queryImpl.limit, startAt, endAt);
   }
 }
-function queryWithLimit(query, limit, limitType) {
-  return new QueryImpl(query.path, query.collectionGroup, query.explicitOrderBy.slice(), query.filters.slice(), limit, limitType, query.startAt, query.endAt);
+function queryWithAddedFilter(query2, filter2) {
+  const newFilters = query2.filters.concat([filter2]);
+  return new QueryImpl(query2.path, query2.collectionGroup, query2.explicitOrderBy.slice(), newFilters, query2.limit, query2.limitType, query2.startAt, query2.endAt);
+}
+function queryWithLimit(query2, limit, limitType) {
+  return new QueryImpl(query2.path, query2.collectionGroup, query2.explicitOrderBy.slice(), query2.filters.slice(), limit, limitType, query2.startAt, query2.endAt);
 }
 function queryEquals(left, right) {
   return targetEquals(queryToTarget(left), queryToTarget(right)) && left.limitType === right.limitType;
 }
-function canonifyQuery(query) {
-  return `${canonifyTarget(queryToTarget(query))}|lt:${query.limitType}`;
+function canonifyQuery(query2) {
+  return `${canonifyTarget(queryToTarget(query2))}|lt:${query2.limitType}`;
 }
-function stringifyQuery(query) {
-  return `Query(target=${stringifyTarget(queryToTarget(query))}; limitType=${query.limitType})`;
+function stringifyQuery(query2) {
+  return `Query(target=${stringifyTarget(queryToTarget(query2))}; limitType=${query2.limitType})`;
 }
-function queryMatches(query, doc3) {
-  return doc3.isFoundDocument() && queryMatchesPathAndCollectionGroup(query, doc3) && queryMatchesOrderBy(query, doc3) && queryMatchesFilters(query, doc3) && queryMatchesBounds(query, doc3);
+function queryMatches(query2, doc3) {
+  return doc3.isFoundDocument() && queryMatchesPathAndCollectionGroup(query2, doc3) && queryMatchesOrderBy(query2, doc3) && queryMatchesFilters(query2, doc3) && queryMatchesBounds(query2, doc3);
 }
-function queryMatchesPathAndCollectionGroup(query, doc3) {
+function queryMatchesPathAndCollectionGroup(query2, doc3) {
   const docPath = doc3.key.path;
-  if (query.collectionGroup !== null) {
-    return doc3.key.hasCollectionId(query.collectionGroup) && query.path.isPrefixOf(docPath);
-  } else if (DocumentKey.isDocumentKey(query.path)) {
-    return query.path.isEqual(docPath);
+  if (query2.collectionGroup !== null) {
+    return doc3.key.hasCollectionId(query2.collectionGroup) && query2.path.isPrefixOf(docPath);
+  } else if (DocumentKey.isDocumentKey(query2.path)) {
+    return query2.path.isEqual(docPath);
   } else {
-    return query.path.isImmediateParentOf(docPath);
+    return query2.path.isImmediateParentOf(docPath);
   }
 }
-function queryMatchesOrderBy(query, doc3) {
-  for (const orderBy of queryNormalizedOrderBy(query)) {
+function queryMatchesOrderBy(query2, doc3) {
+  for (const orderBy of queryNormalizedOrderBy(query2)) {
     if (!orderBy.field.isKeyField() && doc3.data.field(orderBy.field) === null) {
       return false;
     }
   }
   return true;
 }
-function queryMatchesFilters(query, doc3) {
-  for (const filter2 of query.filters) {
+function queryMatchesFilters(query2, doc3) {
+  for (const filter2 of query2.filters) {
     if (!filter2.matches(doc3)) {
       return false;
     }
   }
   return true;
 }
-function queryMatchesBounds(query, doc3) {
-  if (query.startAt && !boundSortsBeforeDocument(query.startAt, queryNormalizedOrderBy(query), doc3)) {
+function queryMatchesBounds(query2, doc3) {
+  if (query2.startAt && !boundSortsBeforeDocument(query2.startAt, queryNormalizedOrderBy(query2), doc3)) {
     return false;
   }
-  if (query.endAt && !boundSortsAfterDocument(query.endAt, queryNormalizedOrderBy(query), doc3)) {
+  if (query2.endAt && !boundSortsAfterDocument(query2.endAt, queryNormalizedOrderBy(query2), doc3)) {
     return false;
   }
   return true;
 }
-function queryCollectionGroup(query) {
-  return query.collectionGroup || (query.path.length % 2 === 1 ? query.path.lastSegment() : query.path.get(query.path.length - 2));
+function queryCollectionGroup(query2) {
+  return query2.collectionGroup || (query2.path.length % 2 === 1 ? query2.path.lastSegment() : query2.path.get(query2.path.length - 2));
 }
-function newQueryComparator(query) {
+function newQueryComparator(query2) {
   return (d1, d2) => {
     let comparedOnKeyField = false;
-    for (const orderBy of queryNormalizedOrderBy(query)) {
+    for (const orderBy of queryNormalizedOrderBy(query2)) {
       const comp = compareDocs(orderBy, d1, d2);
       if (comp !== 0) {
         return comp;
@@ -23074,6 +23083,28 @@ function asNumber(value) {
 function coercedFieldValuesArray(value) {
   return isArray(value) && value.arrayValue.values ? value.arrayValue.values.slice() : [];
 }
+/**
+ * @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.
+ */
+class FieldTransform {
+  constructor(field2, transform) {
+    this.field = field2;
+    this.transform = transform;
+  }
+}
 function fieldTransformEquals(left, right) {
   return left.field.isEqual(right.field) && transformOperationEquals(left.transform, right.transform);
 }
@@ -24761,9 +24792,9 @@ function toQueryTarget(serializer, target) {
     queryTarget.structuredQuery.from = [{ collectionId: path2.lastSegment() }];
   }
   queryTarget.parent = toQueryPath(serializer, parent);
-  const where = toFilters(target.filters);
-  if (where) {
-    queryTarget.structuredQuery.where = where;
+  const where2 = toFilters(target.filters);
+  if (where2) {
+    queryTarget.structuredQuery.where = where2;
   }
   const orderBy = toOrder(target.orderBy);
   if (orderBy) {
@@ -24783,12 +24814,12 @@ function toQueryTarget(serializer, target) {
 }
 function convertQueryTargetToQuery(target) {
   let path2 = fromQueryPath(target.parent);
-  const query = target.structuredQuery;
-  const fromCount = query.from ? query.from.length : 0;
+  const query2 = target.structuredQuery;
+  const fromCount = query2.from ? query2.from.length : 0;
   let collectionGroup = null;
   if (fromCount > 0) {
     hardAssert(fromCount === 1, 65062);
-    const from = query.from[0];
+    const from = query2.from[0];
     if (from.allDescendants) {
       collectionGroup = from.collectionId;
     } else {
@@ -24796,24 +24827,24 @@ function convertQueryTargetToQuery(target) {
     }
   }
   let filterBy = [];
-  if (query.where) {
-    filterBy = fromFilters(query.where);
+  if (query2.where) {
+    filterBy = fromFilters(query2.where);
   }
   let orderBy = [];
-  if (query.orderBy) {
-    orderBy = fromOrder(query.orderBy);
+  if (query2.orderBy) {
+    orderBy = fromOrder(query2.orderBy);
   }
   let limit = null;
-  if (query.limit) {
-    limit = fromInt32Proto(query.limit);
+  if (query2.limit) {
+    limit = fromInt32Proto(query2.limit);
   }
   let startAt = null;
-  if (query.startAt) {
-    startAt = fromStartAtCursor(query.startAt);
+  if (query2.startAt) {
+    startAt = fromStartAtCursor(query2.startAt);
   }
   let endAt = null;
-  if (query.endAt) {
-    endAt = fromEndAtCursor(query.endAt);
+  if (query2.endAt) {
+    endAt = fromEndAtCursor(query2.endAt);
   }
   return newQuery(path2, collectionGroup, orderBy, filterBy, limit, "F", startAt, endAt);
 }
@@ -25187,19 +25218,19 @@ class LocalSerializer {
   }
 }
 function fromBundledQuery(bundledQuery) {
-  const query = convertQueryTargetToQuery({
+  const query2 = convertQueryTargetToQuery({
     parent: bundledQuery.parent,
     structuredQuery: bundledQuery.structuredQuery
   });
   if (bundledQuery.limitType === "LAST") {
     return queryWithLimit(
-      query,
-      query.limit,
+      query2,
+      query2.limit,
       "L"
       /* LimitType.Last */
     );
   }
-  return query;
+  return query2;
 }
 function fromProtoNamedQuery(namedQuery) {
   return {
@@ -25852,13 +25883,13 @@ class LocalDocumentsView {
    * @param context - A optional tracker to keep a record of important details
    *   during database local query execution.
    */
-  getDocumentsMatchingQuery(transaction, query, offset, context) {
-    if (isDocumentQuery$1(query)) {
-      return this.getDocumentsMatchingDocumentQuery(transaction, query.path);
-    } else if (isCollectionGroupQuery(query)) {
-      return this.getDocumentsMatchingCollectionGroupQuery(transaction, query, offset, context);
+  getDocumentsMatchingQuery(transaction, query2, offset, context) {
+    if (isDocumentQuery$1(query2)) {
+      return this.getDocumentsMatchingDocumentQuery(transaction, query2.path);
+    } else if (isCollectionGroupQuery(query2)) {
+      return this.getDocumentsMatchingCollectionGroupQuery(transaction, query2, offset, context);
     } else {
-      return this.getDocumentsMatchingCollectionQuery(transaction, query, offset, context);
+      return this.getDocumentsMatchingCollectionQuery(transaction, query2, offset, context);
     }
   }
   /**
@@ -25908,12 +25939,12 @@ class LocalDocumentsView {
       return result;
     });
   }
-  getDocumentsMatchingCollectionGroupQuery(transaction, query, offset, context) {
-    const collectionId = query.collectionGroup;
+  getDocumentsMatchingCollectionGroupQuery(transaction, query2, offset, context) {
+    const collectionId = query2.collectionGroup;
     let results = documentMap();
     return this.indexManager.getCollectionParents(transaction, collectionId).next((parents) => {
       return PersistencePromise.forEach(parents, (parent) => {
-        const collectionQuery = asCollectionQueryAtPath(query, parent.child(collectionId));
+        const collectionQuery = asCollectionQueryAtPath(query2, parent.child(collectionId));
         return this.getDocumentsMatchingCollectionQuery(transaction, collectionQuery, offset, context).next((r) => {
           r.forEach((key, doc3) => {
             results = results.insert(key, doc3);
@@ -25922,11 +25953,11 @@ class LocalDocumentsView {
       }).next(() => results);
     });
   }
-  getDocumentsMatchingCollectionQuery(transaction, query, offset, context) {
+  getDocumentsMatchingCollectionQuery(transaction, query2, offset, context) {
     let overlays;
-    return this.documentOverlayCache.getOverlaysForCollection(transaction, query.path, offset.largestBatchId).next((result) => {
+    return this.documentOverlayCache.getOverlaysForCollection(transaction, query2.path, offset.largestBatchId).next((result) => {
       overlays = result;
-      return this.remoteDocumentCache.getDocumentsMatchingQuery(transaction, query, offset, overlays, context);
+      return this.remoteDocumentCache.getDocumentsMatchingQuery(transaction, query2, offset, overlays, context);
     }).next((remoteDocuments) => {
       overlays.forEach((_, overlay) => {
         const key = overlay.getKey();
@@ -25940,7 +25971,7 @@ class LocalDocumentsView {
         if (overlay !== void 0) {
           mutationApplyToLocalView(overlay.mutation, document, FieldMask.empty(), Timestamp.now());
         }
-        if (queryMatches(query, document)) {
+        if (queryMatches(query2, document)) {
           results = results.insert(key, document);
         }
       });
@@ -25980,8 +26011,8 @@ class MemoryBundleCache {
   getNamedQuery(transaction, queryName) {
     return PersistencePromise.resolve(this.namedQueries.get(queryName));
   }
-  saveNamedQuery(transaction, query) {
-    this.namedQueries.set(query.name, fromProtoNamedQuery(query));
+  saveNamedQuery(transaction, query2) {
+    this.namedQueries.set(query2.name, fromProtoNamedQuery(query2));
     return PersistencePromise.resolve();
   }
 }
@@ -26302,8 +26333,8 @@ class MemoryMutationQueue {
     });
     return PersistencePromise.resolve(this.findMutationBatches(uniqueBatchIDs));
   }
-  getAllMutationBatchesAffectingQuery(transaction, query) {
-    const prefix = query.path;
+  getAllMutationBatchesAffectingQuery(transaction, query2) {
+    const prefix = query2.path;
     const immediateChildrenPathLength = prefix.length + 1;
     let startPath = prefix;
     if (!DocumentKey.isDocumentKey(startPath)) {
@@ -26476,9 +26507,9 @@ class MemoryRemoteDocumentCacheImpl {
     });
     return PersistencePromise.resolve(results);
   }
-  getDocumentsMatchingQuery(transaction, query, offset, mutatedDocs) {
+  getDocumentsMatchingQuery(transaction, query2, offset, mutatedDocs) {
     let results = mutableDocumentMap();
-    const collectionPath = query.path;
+    const collectionPath = query2.path;
     const prefix = new DocumentKey(collectionPath.child("__id" + MIN_LONG_VALUE + "__"));
     const iterator = this.docs.getIteratorFrom(prefix);
     while (iterator.hasNext()) {
@@ -26492,7 +26523,7 @@ class MemoryRemoteDocumentCacheImpl {
       if (indexOffsetComparator(newIndexOffsetFromDocument(document), offset) <= 0) {
         continue;
       }
-      if (!mutatedDocs.has(document.key) && !queryMatches(query, document)) {
+      if (!mutatedDocs.has(document.key) && !queryMatches(query2, document)) {
         continue;
       }
       results = results.insert(document.key, document.mutableCopy());
@@ -27281,7 +27312,7 @@ async function localStoreReleaseTarget(localStore, targetId, keepPersistedTarget
   localStoreImpl.targetDataByTarget = localStoreImpl.targetDataByTarget.remove(targetId);
   localStoreImpl.targetIdByTarget.delete(targetData.target);
 }
-function localStoreExecuteQuery(localStore, query, usePreviousResults) {
+function localStoreExecuteQuery(localStore, query2, usePreviousResults) {
   const localStoreImpl = debugCast(localStore);
   let lastLimboFreeSnapshotVersion = SnapshotVersion.min();
   let remoteKeys = documentKeySet();
@@ -27291,15 +27322,15 @@ function localStoreExecuteQuery(localStore, query, usePreviousResults) {
     // Use readwrite instead of readonly so indexes can be created
     // Use readwrite instead of readonly so indexes can be created
     (txn) => {
-      return localStoreGetTargetData(localStoreImpl, txn, queryToTarget(query)).next((targetData) => {
+      return localStoreGetTargetData(localStoreImpl, txn, queryToTarget(query2)).next((targetData) => {
         if (targetData) {
           lastLimboFreeSnapshotVersion = targetData.lastLimboFreeSnapshotVersion;
           return localStoreImpl.targetCache.getMatchingKeysForTargetId(txn, targetData.targetId).next((result) => {
             remoteKeys = result;
           });
         }
-      }).next(() => localStoreImpl.queryEngine.getDocumentsMatchingQuery(txn, query, usePreviousResults ? lastLimboFreeSnapshotVersion : SnapshotVersion.min(), usePreviousResults ? remoteKeys : documentKeySet())).next((documents) => {
-        setMaxReadTime(localStoreImpl, queryCollectionGroup(query), documents);
+      }).next(() => localStoreImpl.queryEngine.getDocumentsMatchingQuery(txn, query2, usePreviousResults ? lastLimboFreeSnapshotVersion : SnapshotVersion.min(), usePreviousResults ? remoteKeys : documentKeySet())).next((documents) => {
+        setMaxReadTime(localStoreImpl, queryCollectionGroup(query2), documents);
         return { documents, remoteKeys };
       });
     }
@@ -27400,15 +27431,15 @@ class QueryEngine {
     this.initialized = true;
   }
   /** Returns all local documents matching the specified query. */
-  getDocumentsMatchingQuery(transaction, query, lastLimboFreeSnapshotVersion, remoteKeys) {
+  getDocumentsMatchingQuery(transaction, query2, lastLimboFreeSnapshotVersion, remoteKeys) {
     const queryResult = { result: null };
-    return this.performQueryUsingIndex(transaction, query).next((result) => {
+    return this.performQueryUsingIndex(transaction, query2).next((result) => {
       queryResult.result = result;
     }).next(() => {
       if (queryResult.result) {
         return;
       }
-      return this.performQueryUsingRemoteKeys(transaction, query, remoteKeys, lastLimboFreeSnapshotVersion).next((result) => {
+      return this.performQueryUsingRemoteKeys(transaction, query2, remoteKeys, lastLimboFreeSnapshotVersion).next((result) => {
         queryResult.result = result;
       });
     }).next(() => {
@@ -27416,29 +27447,29 @@ class QueryEngine {
         return;
       }
       const context = new QueryContext();
-      return this.executeFullCollectionScan(transaction, query, context).next((result) => {
+      return this.executeFullCollectionScan(transaction, query2, context).next((result) => {
         queryResult.result = result;
         if (this.indexAutoCreationEnabled) {
-          return this.createCacheIndexes(transaction, query, context, result.size);
+          return this.createCacheIndexes(transaction, query2, context, result.size);
         }
       });
     }).next(() => queryResult.result);
   }
-  createCacheIndexes(transaction, query, context, resultSize) {
+  createCacheIndexes(transaction, query2, context, resultSize) {
     if (context.documentReadCount < this.indexAutoCreationMinCollectionSize) {
       if (getLogLevel() <= LogLevel.DEBUG) {
-        logDebug("QueryEngine", "SDK will not create cache indexes for query:", stringifyQuery(query), "since it only creates cache indexes for collection contains", "more than or equal to", this.indexAutoCreationMinCollectionSize, "documents");
+        logDebug("QueryEngine", "SDK will not create cache indexes for query:", stringifyQuery(query2), "since it only creates cache indexes for collection contains", "more than or equal to", this.indexAutoCreationMinCollectionSize, "documents");
       }
       return PersistencePromise.resolve();
     }
     if (getLogLevel() <= LogLevel.DEBUG) {
-      logDebug("QueryEngine", "Query:", stringifyQuery(query), "scans", context.documentReadCount, "local documents and returns", resultSize, "documents as results.");
+      logDebug("QueryEngine", "Query:", stringifyQuery(query2), "scans", context.documentReadCount, "local documents and returns", resultSize, "documents as results.");
     }
     if (context.documentReadCount > this.relativeIndexReadCostPerDocument * resultSize) {
       if (getLogLevel() <= LogLevel.DEBUG) {
-        logDebug("QueryEngine", "The SDK decides to create cache indexes for query:", stringifyQuery(query), "as using cache indexes may help improve performance.");
+        logDebug("QueryEngine", "The SDK decides to create cache indexes for query:", stringifyQuery(query2), "as using cache indexes may help improve performance.");
       }
-      return this.indexManager.createTargetIndexes(transaction, queryToTarget(query));
+      return this.indexManager.createTargetIndexes(transaction, queryToTarget(query2));
     }
     return PersistencePromise.resolve();
   }
@@ -27446,38 +27477,38 @@ class QueryEngine {
    * Performs an indexed query that evaluates the query based on a collection's
    * persisted index values. Returns `null` if an index is not available.
    */
-  performQueryUsingIndex(transaction, query) {
-    if (queryMatchesAllDocuments(query)) {
+  performQueryUsingIndex(transaction, query2) {
+    if (queryMatchesAllDocuments(query2)) {
       return PersistencePromise.resolve(null);
     }
-    let target = queryToTarget(query);
+    let target = queryToTarget(query2);
     return this.indexManager.getIndexType(transaction, target).next((indexType) => {
       if (indexType === 0) {
         return null;
       }
-      if (query.limit !== null && indexType === 1) {
-        query = queryWithLimit(
-          query,
+      if (query2.limit !== null && indexType === 1) {
+        query2 = queryWithLimit(
+          query2,
           null,
           "F"
           /* LimitType.First */
         );
-        target = queryToTarget(query);
+        target = queryToTarget(query2);
       }
       return this.indexManager.getDocumentsMatchingTarget(transaction, target).next((keys) => {
         const sortedKeys = documentKeySet(...keys);
         return this.localDocumentsView.getDocuments(transaction, sortedKeys).next((indexedDocuments) => {
           return this.indexManager.getMinOffset(transaction, target).next((offset) => {
-            const previousResults = this.applyQuery(query, indexedDocuments);
-            if (this.needsRefill(query, previousResults, sortedKeys, offset.readTime)) {
+            const previousResults = this.applyQuery(query2, indexedDocuments);
+            if (this.needsRefill(query2, previousResults, sortedKeys, offset.readTime)) {
               return this.performQueryUsingIndex(transaction, queryWithLimit(
-                query,
+                query2,
                 null,
                 "F"
                 /* LimitType.First */
               ));
             }
-            return this.appendRemainingResults(transaction, previousResults, query, offset);
+            return this.appendRemainingResults(transaction, previousResults, query2, offset);
           });
         });
       });
@@ -27487,29 +27518,29 @@ class QueryEngine {
    * Performs a query based on the target's persisted query mapping. Returns
    * `null` if the mapping is not available or cannot be used.
    */
-  performQueryUsingRemoteKeys(transaction, query, remoteKeys, lastLimboFreeSnapshotVersion) {
-    if (queryMatchesAllDocuments(query)) {
+  performQueryUsingRemoteKeys(transaction, query2, remoteKeys, lastLimboFreeSnapshotVersion) {
+    if (queryMatchesAllDocuments(query2)) {
       return PersistencePromise.resolve(null);
     }
     if (lastLimboFreeSnapshotVersion.isEqual(SnapshotVersion.min())) {
       return PersistencePromise.resolve(null);
     }
     return this.localDocumentsView.getDocuments(transaction, remoteKeys).next((documents) => {
-      const previousResults = this.applyQuery(query, documents);
-      if (this.needsRefill(query, previousResults, remoteKeys, lastLimboFreeSnapshotVersion)) {
+      const previousResults = this.applyQuery(query2, documents);
+      if (this.needsRefill(query2, previousResults, remoteKeys, lastLimboFreeSnapshotVersion)) {
         return PersistencePromise.resolve(null);
       }
       if (getLogLevel() <= LogLevel.DEBUG) {
-        logDebug("QueryEngine", "Re-using previous result from %s to execute query: %s", lastLimboFreeSnapshotVersion.toString(), stringifyQuery(query));
+        logDebug("QueryEngine", "Re-using previous result from %s to execute query: %s", lastLimboFreeSnapshotVersion.toString(), stringifyQuery(query2));
       }
-      return this.appendRemainingResults(transaction, previousResults, query, newIndexOffsetSuccessorFromReadTime(lastLimboFreeSnapshotVersion, INITIAL_LARGEST_BATCH_ID)).next((results) => results);
+      return this.appendRemainingResults(transaction, previousResults, query2, newIndexOffsetSuccessorFromReadTime(lastLimboFreeSnapshotVersion, INITIAL_LARGEST_BATCH_ID)).next((results) => results);
     });
   }
   /** Applies the query filter and sorting to the provided documents.  */
-  applyQuery(query, documents) {
-    let queryResults = new SortedSet(newQueryComparator(query));
+  applyQuery(query2, documents) {
+    let queryResults = new SortedSet(newQueryComparator(query2));
     documents.forEach((_, maybeDoc) => {
-      if (queryMatches(query, maybeDoc)) {
+      if (queryMatches(query2, maybeDoc)) {
         queryResults = queryResults.add(maybeDoc);
       }
     });
@@ -27527,31 +27558,31 @@ class QueryEngine {
    * @param limboFreeSnapshotVersion - The version of the snapshot when the
    * query was last synchronized.
    */
-  needsRefill(query, sortedPreviousResults, remoteKeys, limboFreeSnapshotVersion) {
-    if (query.limit === null) {
+  needsRefill(query2, sortedPreviousResults, remoteKeys, limboFreeSnapshotVersion) {
+    if (query2.limit === null) {
       return false;
     }
     if (remoteKeys.size !== sortedPreviousResults.size) {
       return true;
     }
-    const docAtLimitEdge = query.limitType === "F" ? sortedPreviousResults.last() : sortedPreviousResults.first();
+    const docAtLimitEdge = query2.limitType === "F" ? sortedPreviousResults.last() : sortedPreviousResults.first();
     if (!docAtLimitEdge) {
       return false;
     }
     return docAtLimitEdge.hasPendingWrites || docAtLimitEdge.version.compareTo(limboFreeSnapshotVersion) > 0;
   }
-  executeFullCollectionScan(transaction, query, context) {
+  executeFullCollectionScan(transaction, query2, context) {
     if (getLogLevel() <= LogLevel.DEBUG) {
-      logDebug("QueryEngine", "Using full collection scan to execute query:", stringifyQuery(query));
+      logDebug("QueryEngine", "Using full collection scan to execute query:", stringifyQuery(query2));
     }
-    return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query, IndexOffset.min(), context);
+    return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query2, IndexOffset.min(), context);
   }
   /**
    * Combines the results from an indexed execution with the remaining documents
    * that have not yet been indexed.
    */
-  appendRemainingResults(transaction, indexedResults, query, offset) {
-    return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query, offset).next((remainingResults) => {
+  appendRemainingResults(transaction, indexedResults, query2, offset) {
+    return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query2, offset).next((remainingResults) => {
       indexedResults.forEach((d) => {
         remainingResults = remainingResults.insert(d.key, d);
       });
@@ -32296,8 +32327,8 @@ class DocumentChangeSet {
   }
 }
 class ViewSnapshot {
-  constructor(query, docs, oldDocs, docChanges, mutatedKeys, fromCache, syncStateChanged, excludesMetadataChanges, hasCachedResults) {
-    this.query = query;
+  constructor(query2, docs, oldDocs, docChanges, mutatedKeys, fromCache, syncStateChanged, excludesMetadataChanges, hasCachedResults) {
+    this.query = query2;
     this.docs = docs;
     this.oldDocs = oldDocs;
     this.docChanges = docChanges;
@@ -32308,13 +32339,13 @@ class ViewSnapshot {
     this.hasCachedResults = hasCachedResults;
   }
   /** Returns a view snapshot as if all documents in the snapshot were added. */
-  static fromInitialDocuments(query, documents, mutatedKeys, fromCache, hasCachedResults) {
+  static fromInitialDocuments(query2, documents, mutatedKeys, fromCache, hasCachedResults) {
     const changes = [];
     documents.forEach((doc3) => {
       changes.push({ type: 0, doc: doc3 });
     });
     return new ViewSnapshot(
-      query,
+      query2,
       documents,
       DocumentSet.emptySet(documents),
       changes,
@@ -32392,8 +32423,8 @@ function newQueriesObjectMap() {
 async function eventManagerListen(eventManager, listener) {
   const eventManagerImpl = debugCast(eventManager);
   let listenerAction = 3;
-  const query = listener.query;
-  let queryInfo = eventManagerImpl.queries.get(query);
+  const query2 = listener.query;
+  let queryInfo = eventManagerImpl.queries.get(query2);
   if (!queryInfo) {
     queryInfo = new QueryListenersInfo();
     listenerAction = listener.listensToRemoteStore() ? 0 : 1;
@@ -32404,20 +32435,20 @@ async function eventManagerListen(eventManager, listener) {
     switch (listenerAction) {
       case 0:
         queryInfo.viewSnap = await eventManagerImpl.onListen(
-          query,
+          query2,
           /** enableRemoteListen= */
           true
         );
         break;
       case 1:
         queryInfo.viewSnap = await eventManagerImpl.onListen(
-          query,
+          query2,
           /** enableRemoteListen= */
           false
         );
         break;
       case 2:
-        await eventManagerImpl.onFirstRemoteStoreListen(query);
+        await eventManagerImpl.onFirstRemoteStoreListen(query2);
         break;
       default:
         break;
@@ -32427,7 +32458,7 @@ async function eventManagerListen(eventManager, listener) {
     listener.onError(firestoreError);
     return;
   }
-  eventManagerImpl.queries.set(query, queryInfo);
+  eventManagerImpl.queries.set(query2, queryInfo);
   queryInfo.listeners.push(listener);
   listener.applyOnlineStateChange(eventManagerImpl.onlineState);
   if (queryInfo.viewSnap) {
@@ -32439,9 +32470,9 @@ async function eventManagerListen(eventManager, listener) {
 }
 async function eventManagerUnlisten(eventManager, listener) {
   const eventManagerImpl = debugCast(eventManager);
-  const query = listener.query;
+  const query2 = listener.query;
   let listenerAction = 3;
-  const queryInfo = eventManagerImpl.queries.get(query);
+  const queryInfo = eventManagerImpl.queries.get(query2);
   if (queryInfo) {
     const i = queryInfo.listeners.indexOf(listener);
     if (i >= 0) {
@@ -32455,21 +32486,21 @@ async function eventManagerUnlisten(eventManager, listener) {
   }
   switch (listenerAction) {
     case 0:
-      eventManagerImpl.queries.delete(query);
+      eventManagerImpl.queries.delete(query2);
       return eventManagerImpl.onUnlisten(
-        query,
+        query2,
         /** disableRemoteListen= */
         true
       );
     case 1:
-      eventManagerImpl.queries.delete(query);
+      eventManagerImpl.queries.delete(query2);
       return eventManagerImpl.onUnlisten(
-        query,
+        query2,
         /** disableRemoteListen= */
         false
       );
     case 2:
-      return eventManagerImpl.onLastRemoteStoreUnlisten(query);
+      return eventManagerImpl.onLastRemoteStoreUnlisten(query2);
     default:
       return;
   }
@@ -32478,8 +32509,8 @@ function eventManagerOnWatchChange(eventManager, viewSnaps) {
   const eventManagerImpl = debugCast(eventManager);
   let raisedEvent = false;
   for (const viewSnap of viewSnaps) {
-    const query = viewSnap.query;
-    const queryInfo = eventManagerImpl.queries.get(query);
+    const query2 = viewSnap.query;
+    const queryInfo = eventManagerImpl.queries.get(query2);
     if (queryInfo) {
       for (const listener of queryInfo.listeners) {
         if (listener.onViewSnapshot(viewSnap)) {
@@ -32493,15 +32524,15 @@ function eventManagerOnWatchChange(eventManager, viewSnaps) {
     raiseSnapshotsInSyncEvent(eventManagerImpl);
   }
 }
-function eventManagerOnWatchError(eventManager, query, error2) {
+function eventManagerOnWatchError(eventManager, query2, error2) {
   const eventManagerImpl = debugCast(eventManager);
-  const queryInfo = eventManagerImpl.queries.get(query);
+  const queryInfo = eventManagerImpl.queries.get(query2);
   if (queryInfo) {
     for (const listener of queryInfo.listeners) {
       listener.onError(error2);
     }
   }
-  eventManagerImpl.queries.delete(query);
+  eventManagerImpl.queries.delete(query2);
 }
 function eventManagerOnOnlineStateChange(eventManager, onlineState) {
   const eventManagerImpl = debugCast(eventManager);
@@ -32539,8 +32570,8 @@ var ListenerDataSource;
   ListenerDataSource2["Cache"] = "cache";
 })(ListenerDataSource || (ListenerDataSource = {}));
 class QueryListener {
-  constructor(query, queryObserver, options) {
-    this.query = query;
+  constructor(query2, queryObserver, options) {
+    this.query = query2;
     this.queryObserver = queryObserver;
     this.raisedInitialEvent = false;
     this.snap = null;
@@ -32698,15 +32729,15 @@ class RemovedLimboDocument {
   }
 }
 class View {
-  constructor(query, _syncedDocuments) {
-    this.query = query;
+  constructor(query2, _syncedDocuments) {
+    this.query = query2;
     this._syncedDocuments = _syncedDocuments;
     this.syncState = null;
     this.hasCachedResults = false;
     this.current = false;
     this.limboDocuments = documentKeySet();
     this.mutatedKeys = documentKeySet();
-    this.docComparator = newQueryComparator(query);
+    this.docComparator = newQueryComparator(query2);
     this.documentSet = new DocumentSet(this.docComparator);
   }
   /**
@@ -32999,8 +33030,8 @@ function compareChangeType(c1, c2) {
  */
 const LOG_TAG$3 = "SyncEngine";
 class QueryView {
-  constructor(query, targetId, view) {
-    this.query = query;
+  constructor(query2, targetId, view) {
+    this.query = query2;
     this.targetId = targetId;
     this.view = view;
   }
@@ -33043,17 +33074,17 @@ function newSyncEngine(localStore, remoteStore, eventManager, sharedClientState,
   }
   return syncEngine;
 }
-async function syncEngineListen(syncEngine, query, shouldListenToRemote = true) {
+async function syncEngineListen(syncEngine, query2, shouldListenToRemote = true) {
   const syncEngineImpl = ensureWatchCallbacks(syncEngine);
   let viewSnapshot;
-  const queryView = syncEngineImpl.queryViewsByQuery.get(query);
+  const queryView = syncEngineImpl.queryViewsByQuery.get(query2);
   if (queryView) {
     syncEngineImpl.sharedClientState.addLocalQueryTarget(queryView.targetId);
     viewSnapshot = queryView.view.computeInitialSnapshot();
   } else {
     viewSnapshot = await allocateTargetAndMaybeListen(
       syncEngineImpl,
-      query,
+      query2,
       shouldListenToRemote,
       /** shouldInitializeView= */
       true
@@ -33061,19 +33092,19 @@ async function syncEngineListen(syncEngine, query, shouldListenToRemote = true)
   }
   return viewSnapshot;
 }
-async function triggerRemoteStoreListen(syncEngine, query) {
+async function triggerRemoteStoreListen(syncEngine, query2) {
   const syncEngineImpl = ensureWatchCallbacks(syncEngine);
   await allocateTargetAndMaybeListen(
     syncEngineImpl,
-    query,
+    query2,
     /** shouldListenToRemote= */
     true,
     /** shouldInitializeView= */
     false
   );
 }
-async function allocateTargetAndMaybeListen(syncEngineImpl, query, shouldListenToRemote, shouldInitializeView) {
-  const targetData = await localStoreAllocateTarget(syncEngineImpl.localStore, queryToTarget(query));
+async function allocateTargetAndMaybeListen(syncEngineImpl, query2, shouldListenToRemote, shouldInitializeView) {
+  const targetData = await localStoreAllocateTarget(syncEngineImpl.localStore, queryToTarget(query2));
   const targetId = targetData.targetId;
   const status = syncEngineImpl.sharedClientState.addLocalQueryTarget(
     targetId,
@@ -33082,22 +33113,22 @@ async function allocateTargetAndMaybeListen(syncEngineImpl, query, shouldListenT
   );
   let viewSnapshot;
   if (shouldInitializeView) {
-    viewSnapshot = await initializeViewAndComputeSnapshot(syncEngineImpl, query, targetId, status === "current", targetData.resumeToken);
+    viewSnapshot = await initializeViewAndComputeSnapshot(syncEngineImpl, query2, targetId, status === "current", targetData.resumeToken);
   }
   if (syncEngineImpl.isPrimaryClient && shouldListenToRemote) {
     remoteStoreListen(syncEngineImpl.remoteStore, targetData);
   }
   return viewSnapshot;
 }
-async function initializeViewAndComputeSnapshot(syncEngineImpl, query, targetId, current, resumeToken) {
+async function initializeViewAndComputeSnapshot(syncEngineImpl, query2, targetId, current, resumeToken) {
   syncEngineImpl.applyDocChanges = (queryView, changes, remoteEvent) => applyDocChanges(syncEngineImpl, queryView, changes, remoteEvent);
   const queryResult = await localStoreExecuteQuery(
     syncEngineImpl.localStore,
-    query,
+    query2,
     /* usePreviousResults= */
     true
   );
-  const view = new View(query, queryResult.remoteKeys);
+  const view = new View(query2, queryResult.remoteKeys);
   const viewDocChanges = view.computeDocChanges(queryResult.documents);
   const synthesizedTargetChange = TargetChange.createSynthesizedTargetChangeForCurrentChange(targetId, current && syncEngineImpl.onlineState !== "Offline", resumeToken);
   const viewChange = view.applyChanges(
@@ -33107,22 +33138,22 @@ async function initializeViewAndComputeSnapshot(syncEngineImpl, query, targetId,
     synthesizedTargetChange
   );
   updateTrackedLimbos(syncEngineImpl, targetId, viewChange.limboChanges);
-  const data = new QueryView(query, targetId, view);
-  syncEngineImpl.queryViewsByQuery.set(query, data);
+  const data = new QueryView(query2, targetId, view);
+  syncEngineImpl.queryViewsByQuery.set(query2, data);
   if (syncEngineImpl.queriesByTarget.has(targetId)) {
-    syncEngineImpl.queriesByTarget.get(targetId).push(query);
+    syncEngineImpl.queriesByTarget.get(targetId).push(query2);
   } else {
-    syncEngineImpl.queriesByTarget.set(targetId, [query]);
+    syncEngineImpl.queriesByTarget.set(targetId, [query2]);
   }
   return viewChange.snapshot;
 }
-async function syncEngineUnlisten(syncEngine, query, shouldUnlistenToRemote) {
+async function syncEngineUnlisten(syncEngine, query2, shouldUnlistenToRemote) {
   const syncEngineImpl = debugCast(syncEngine);
-  const queryView = syncEngineImpl.queryViewsByQuery.get(query);
+  const queryView = syncEngineImpl.queryViewsByQuery.get(query2);
   const queries = syncEngineImpl.queriesByTarget.get(queryView.targetId);
   if (queries.length > 1) {
-    syncEngineImpl.queriesByTarget.set(queryView.targetId, queries.filter((q) => !queryEquals(q, query)));
-    syncEngineImpl.queryViewsByQuery.delete(query);
+    syncEngineImpl.queriesByTarget.set(queryView.targetId, queries.filter((q) => !queryEquals(q, query2)));
+    syncEngineImpl.queryViewsByQuery.delete(query2);
     return;
   }
   if (syncEngineImpl.isPrimaryClient) {
@@ -33152,9 +33183,9 @@ async function syncEngineUnlisten(syncEngine, query, shouldUnlistenToRemote) {
     );
   }
 }
-async function triggerRemoteStoreUnlisten(syncEngine, query) {
+async function triggerRemoteStoreUnlisten(syncEngine, query2) {
   const syncEngineImpl = debugCast(syncEngine);
-  const queryView = syncEngineImpl.queryViewsByQuery.get(query);
+  const queryView = syncEngineImpl.queryViewsByQuery.get(query2);
   const queries = syncEngineImpl.queriesByTarget.get(queryView.targetId);
   if (syncEngineImpl.isPrimaryClient && queries.length === 1) {
     syncEngineImpl.sharedClientState.removeLocalQueryTarget(queryView.targetId);
@@ -33202,7 +33233,7 @@ function syncEngineApplyOnlineStateChange(syncEngine, onlineState, source) {
   const syncEngineImpl = debugCast(syncEngine);
   if (syncEngineImpl.isPrimaryClient && source === 0 || !syncEngineImpl.isPrimaryClient && source === 1) {
     const newViewSnapshots = [];
-    syncEngineImpl.queryViewsByQuery.forEach((query, queryView) => {
+    syncEngineImpl.queryViewsByQuery.forEach((query2, queryView) => {
       const viewChange = queryView.view.applyOnlineStateChange(onlineState);
       if (viewChange.snapshot) {
         newViewSnapshots.push(viewChange.snapshot);
@@ -33319,10 +33350,10 @@ function processUserCallback(syncEngine, batchId, error2) {
 }
 function removeAndCleanupTarget(syncEngineImpl, targetId, error2 = null) {
   syncEngineImpl.sharedClientState.removeLocalQueryTarget(targetId);
-  for (const query of syncEngineImpl.queriesByTarget.get(targetId)) {
-    syncEngineImpl.queryViewsByQuery.delete(query);
+  for (const query2 of syncEngineImpl.queriesByTarget.get(targetId)) {
+    syncEngineImpl.queryViewsByQuery.delete(query2);
     if (error2) {
-      syncEngineImpl.syncEngineListener.onWatchError(query, error2);
+      syncEngineImpl.syncEngineListener.onWatchError(query2, error2);
     }
   }
   syncEngineImpl.queriesByTarget.delete(targetId);
@@ -33459,8 +33490,8 @@ function syncEngineGetRemoteKeysForTarget(syncEngine, targetId) {
     if (!queries) {
       return keySet;
     }
-    for (const query of queries) {
-      const queryView = syncEngineImpl.queryViewsByQuery.get(query);
+    for (const query2 of queries) {
+      const queryView = syncEngineImpl.queryViewsByQuery.get(query2);
       keySet = keySet.unionWith(queryView.view.syncedDocuments);
     }
     return keySet;
@@ -33827,9 +33858,9 @@ async function getEventManager(client2) {
   eventManager.onLastRemoteStoreUnlisten = triggerRemoteStoreUnlisten.bind(null, onlineComponentProvider.syncEngine);
   return eventManager;
 }
-function firestoreClientListen(client2, query, options, observer) {
+function firestoreClientListen(client2, query2, options, observer) {
   const wrappedObserver = new AsyncObserver(observer);
-  const listener = new QueryListener(query, wrappedObserver, options);
+  const listener = new QueryListener(query2, wrappedObserver, options);
   client2.asyncQueue.enqueueAndForget(async () => {
     const eventManager = await getEventManager(client2);
     return eventManagerListen(eventManager, listener);
@@ -33850,11 +33881,11 @@ function firestoreClientGetDocumentViaSnapshotListener(client2, key, options = {
   });
   return deferred.promise;
 }
-function firestoreClientGetDocumentsViaSnapshotListener(client2, query, options = {}) {
+function firestoreClientGetDocumentsViaSnapshotListener(client2, query2, options = {}) {
   const deferred = new Deferred();
   client2.asyncQueue.enqueueAndForget(async () => {
     const eventManager = await getEventManager(client2);
-    return executeQueryViaSnapshotListener(eventManager, client2.asyncQueue, query, options, deferred);
+    return executeQueryViaSnapshotListener(eventManager, client2.asyncQueue, query2, options, deferred);
   });
   return deferred.promise;
 }
@@ -33888,7 +33919,7 @@ function readDocumentViaSnapshotListener(eventManager, asyncQueue, key, options,
   });
   return eventManagerListen(eventManager, listener);
 }
-function executeQueryViaSnapshotListener(eventManager, asyncQueue, query, options, result) {
+function executeQueryViaSnapshotListener(eventManager, asyncQueue, query2, options, result) {
   const wrappedObserver = new AsyncObserver({
     next: (snapshot) => {
       wrappedObserver.mute();
@@ -33901,7 +33932,7 @@ function executeQueryViaSnapshotListener(eventManager, asyncQueue, query, option
     },
     error: (e) => result.reject(e)
   });
-  const listener = new QueryListener(query, wrappedObserver, {
+  const listener = new QueryListener(query2, wrappedObserver, {
     includeMetadataChanges: true,
     waitForSyncWhenOnline: true
   });
@@ -35218,6 +35249,14 @@ class DeleteFieldValueImpl extends FieldValue {
     return other instanceof DeleteFieldValueImpl;
   }
 }
+class ServerTimestampFieldValueImpl extends FieldValue {
+  _toFieldTransform(context) {
+    return new FieldTransform(context.path, new ServerTimestampTransform());
+  }
+  isEqual(other) {
+    return other instanceof ServerTimestampFieldValueImpl;
+  }
+}
 function parseUpdateData(userDataReader, methodName, targetDoc, input) {
   const context = userDataReader.createContext(1, methodName, targetDoc);
   validatePlainObject("Data must be an object, but it was:", context, input);
@@ -35273,6 +35312,11 @@ function parseUpdateVarargs(userDataReader, methodName, targetDoc, field2, value
   const mask = new FieldMask(fieldMaskPaths);
   return new ParsedUpdateData(updateData, mask, context.fieldTransforms);
 }
+function parseQueryValue(userDataReader, methodName, input, allowArrays = false) {
+  const context = userDataReader.createContext(allowArrays ? 4 : 3, methodName);
+  const parsed = parseData(input, context);
+  return parsed;
+}
 function parseData(input, context) {
   input = getModularInstance(input);
   if (looksLikeJsonObject(input)) {
@@ -35614,11 +35658,210 @@ 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" && query.explicitOrderBy.length === 0) {
+function validateHasExplicitOrderByForLimitToLast(query2) {
+  if (query2.limitType === "L" && query2.explicitOrderBy.length === 0) {
     throw new FirestoreError(Code.UNIMPLEMENTED, "limitToLast() queries require specifying at least one orderBy() clause");
   }
 }
+class AppliableConstraint {
+}
+class QueryConstraint extends AppliableConstraint {
+}
+function query(query2, queryConstraint, ...additionalQueryConstraints) {
+  let queryConstraints = [];
+  if (queryConstraint instanceof AppliableConstraint) {
+    queryConstraints.push(queryConstraint);
+  }
+  queryConstraints = queryConstraints.concat(additionalQueryConstraints);
+  validateQueryConstraintArray(queryConstraints);
+  for (const constraint of queryConstraints) {
+    query2 = constraint._apply(query2);
+  }
+  return query2;
+}
+class QueryFieldFilterConstraint extends QueryConstraint {
+  /**
+   * @internal
+   */
+  constructor(_field, _op, _value) {
+    super();
+    this._field = _field;
+    this._op = _op;
+    this._value = _value;
+    this.type = "where";
+  }
+  static _create(_field, _op, _value) {
+    return new QueryFieldFilterConstraint(_field, _op, _value);
+  }
+  _apply(query2) {
+    const filter2 = this._parse(query2);
+    validateNewFieldFilter(query2._query, filter2);
+    return new Query(query2.firestore, query2.converter, queryWithAddedFilter(query2._query, filter2));
+  }
+  _parse(query2) {
+    const reader2 = newUserDataReader(query2.firestore);
+    const filter2 = newQueryFilter(query2._query, "where", reader2, query2.firestore._databaseId, this._field, this._op, this._value);
+    return filter2;
+  }
+}
+function where(fieldPath, opStr, value) {
+  const op = opStr;
+  const field2 = fieldPathFromArgument("where", fieldPath);
+  return QueryFieldFilterConstraint._create(field2, op, value);
+}
+class QueryCompositeFilterConstraint extends AppliableConstraint {
+  /**
+   * @internal
+   */
+  constructor(type2, _queryConstraints) {
+    super();
+    this.type = type2;
+    this._queryConstraints = _queryConstraints;
+  }
+  static _create(type2, _queryConstraints) {
+    return new QueryCompositeFilterConstraint(type2, _queryConstraints);
+  }
+  _parse(query2) {
+    const parsedFilters = this._queryConstraints.map((queryConstraint) => {
+      return queryConstraint._parse(query2);
+    }).filter((parsedFilter) => parsedFilter.getFilters().length > 0);
+    if (parsedFilters.length === 1) {
+      return parsedFilters[0];
+    }
+    return CompositeFilter.create(parsedFilters, this._getOperator());
+  }
+  _apply(query2) {
+    const parsedFilter = this._parse(query2);
+    if (parsedFilter.getFilters().length === 0) {
+      return query2;
+    }
+    validateNewFilter(query2._query, parsedFilter);
+    return new Query(query2.firestore, query2.converter, queryWithAddedFilter(query2._query, parsedFilter));
+  }
+  _getQueryConstraints() {
+    return this._queryConstraints;
+  }
+  _getOperator() {
+    return this.type === "and" ? "and" : "or";
+  }
+}
+function newQueryFilter(query2, methodName, dataReader, databaseId, fieldPath, op, value) {
+  let fieldValue;
+  if (fieldPath.isKeyField()) {
+    if (op === "array-contains" || op === "array-contains-any") {
+      throw new FirestoreError(Code.INVALID_ARGUMENT, `Invalid Query. You can't perform '${op}' queries on documentId().`);
+    } else if (op === "in" || op === "not-in") {
+      validateDisjunctiveFilterElements(value, op);
+      const referenceList = [];
+      for (const arrayValue of value) {
+        referenceList.push(parseDocumentIdValue(databaseId, query2, arrayValue));
+      }
+      fieldValue = { arrayValue: { values: referenceList } };
+    } else {
+      fieldValue = parseDocumentIdValue(databaseId, query2, value);
+    }
+  } else {
+    if (op === "in" || op === "not-in" || op === "array-contains-any") {
+      validateDisjunctiveFilterElements(value, op);
+    }
+    fieldValue = parseQueryValue(
+      dataReader,
+      methodName,
+      value,
+      /* allowArrays= */
+      op === "in" || op === "not-in"
+      /* Operator.NOT_IN */
+    );
+  }
+  const filter2 = FieldFilter.create(fieldPath, op, fieldValue);
+  return filter2;
+}
+function parseDocumentIdValue(databaseId, query2, documentIdValue) {
+  documentIdValue = getModularInstance(documentIdValue);
+  if (typeof documentIdValue === "string") {
+    if (documentIdValue === "") {
+      throw new FirestoreError(Code.INVALID_ARGUMENT, "Invalid query. When querying with documentId(), you must provide a valid document ID, but it was an empty string.");
+    }
+    if (!isCollectionGroupQuery(query2) && documentIdValue.indexOf("/") !== -1) {
+      throw new FirestoreError(Code.INVALID_ARGUMENT, `Invalid query. When querying a collection by documentId(), you must provide a plain document ID, but '${documentIdValue}' contains a '/' character.`);
+    }
+    const path2 = query2.path.child(ResourcePath.fromString(documentIdValue));
+    if (!DocumentKey.isDocumentKey(path2)) {
+      throw new FirestoreError(Code.INVALID_ARGUMENT, `Invalid query. When querying a collection group by documentId(), the value provided must result in a valid document path, but '${path2}' is not because it has an odd number of segments (${path2.length}).`);
+    }
+    return refValue(databaseId, new DocumentKey(path2));
+  } else if (documentIdValue instanceof DocumentReference) {
+    return refValue(databaseId, documentIdValue._key);
+  } else {
+    throw new FirestoreError(Code.INVALID_ARGUMENT, `Invalid query. When querying with documentId(), you must provide a valid string or a DocumentReference, but it was: ${valueDescription(documentIdValue)}.`);
+  }
+}
+function validateDisjunctiveFilterElements(value, operator) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new FirestoreError(Code.INVALID_ARGUMENT, `Invalid Query. A non-empty array is required for '${operator.toString()}' filters.`);
+  }
+}
+function conflictingOps(op) {
+  switch (op) {
+    case "!=":
+      return [
+        "!=",
+        "not-in"
+        /* Operator.NOT_IN */
+      ];
+    case "array-contains-any":
+    case "in":
+      return [
+        "not-in"
+        /* Operator.NOT_IN */
+      ];
+    case "not-in":
+      return [
+        "array-contains-any",
+        "in",
+        "not-in",
+        "!="
+        /* Operator.NOT_EQUAL */
+      ];
+    default:
+      return [];
+  }
+}
+function validateNewFieldFilter(query2, fieldFilter) {
+  const conflictingOp = findOpInsideFilters(query2.filters, conflictingOps(fieldFilter.op));
+  if (conflictingOp !== null) {
+    if (conflictingOp === fieldFilter.op) {
+      throw new FirestoreError(Code.INVALID_ARGUMENT, `Invalid query. You cannot use more than one '${fieldFilter.op.toString()}' filter.`);
+    } else {
+      throw new FirestoreError(Code.INVALID_ARGUMENT, `Invalid query. You cannot use '${fieldFilter.op.toString()}' filters with '${conflictingOp.toString()}' filters.`);
+    }
+  }
+}
+function validateNewFilter(query2, filter2) {
+  let testQuery = query2;
+  const subFilters = filter2.getFlattenedFilters();
+  for (const subFilter of subFilters) {
+    validateNewFieldFilter(testQuery, subFilter);
+    testQuery = queryWithAddedFilter(testQuery, subFilter);
+  }
+}
+function findOpInsideFilters(filters, operators) {
+  for (const filter2 of filters) {
+    for (const fieldFilter of filter2.getFlattenedFilters()) {
+      if (operators.indexOf(fieldFilter.op) >= 0) {
+        return fieldFilter.op;
+      }
+    }
+  }
+  return null;
+}
+function validateQueryConstraintArray(queryConstraint) {
+  const compositeFilterCount = queryConstraint.filter((filter2) => filter2 instanceof QueryCompositeFilterConstraint).length;
+  const fieldFilterCount = queryConstraint.filter((filter2) => filter2 instanceof QueryFieldFilterConstraint).length;
+  if (compositeFilterCount > 1 || compositeFilterCount > 0 && fieldFilterCount > 0) {
+    throw new FirestoreError(Code.INVALID_ARGUMENT, "InvalidQuery. When using composite filters, you cannot use more than one filter at the top level. Consider nesting the multiple filters within an `and(...)` statement. For example: change `query(query, where(...), or(...))` to `query(query, and(where(...), or(...)))`.");
+  }
+}
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -36056,14 +36299,14 @@ function buildDocumentSnapshotJsonBundle(db, document, docData, path2) {
   builder.addBundleDocument(documentToDocumentSnapshotBundleData(path2, docData, document));
   return builder.build();
 }
-function buildQuerySnapshotJsonBundle(db, query, bundleName, parent, paths, docs, documentData) {
+function buildQuerySnapshotJsonBundle(db, query2, bundleName, parent, paths, docs, documentData) {
   const docBundleDataArray = [];
   for (let i = 0; i < docs.length; i++) {
     docBundleDataArray.push(documentToDocumentSnapshotBundleData(paths[i], documentData[i], docs[i]));
   }
   const bundleData = {
     name: bundleName,
-    query,
+    query: query2,
     parent,
     docBundleDataArray
   };
@@ -36222,12 +36465,12 @@ class QueryDocumentSnapshot extends DocumentSnapshot {
 }
 class QuerySnapshot {
   /** @hideconstructor */
-  constructor(_firestore, _userDataWriter, query, _snapshot) {
+  constructor(_firestore, _userDataWriter, query2, _snapshot) {
     this._firestore = _firestore;
     this._userDataWriter = _userDataWriter;
     this._snapshot = _snapshot;
     this.metadata = new SnapshotMetadata(_snapshot.hasPendingWrites, _snapshot.fromCache);
-    this.query = query;
+    this.query = query2;
   }
   /** An array of all the documents in the `QuerySnapshot`. */
   get docs() {
@@ -36406,13 +36649,13 @@ class ExpUserDataWriter extends AbstractUserDataWriter {
     );
   }
 }
-function getDocs(query) {
-  query = cast(query, Query);
-  const firestore = cast(query.firestore, Firestore);
+function getDocs(query2) {
+  query2 = cast(query2, Query);
+  const firestore = cast(query2.firestore, Firestore);
   const client2 = ensureFirestoreConfigured(firestore);
   const userDataWriter = new ExpUserDataWriter(firestore);
-  validateHasExplicitOrderByForLimitToLast(query._query);
-  return firestoreClientGetDocumentsViaSnapshotListener(client2, query._query).then((snapshot) => new QuerySnapshot(firestore, userDataWriter, query, snapshot));
+  validateHasExplicitOrderByForLimitToLast(query2._query);
+  return firestoreClientGetDocumentsViaSnapshotListener(client2, query2._query).then((snapshot) => new QuerySnapshot(firestore, userDataWriter, query2, snapshot));
 }
 function onSnapshot(reference, ...args) {
   var _a, _b, _c;
@@ -36451,14 +36694,14 @@ function onSnapshot(reference, ...args) {
       complete: args[currArg + 2]
     };
   } else {
-    const query = cast(reference, Query);
-    firestore = cast(query.firestore, Firestore);
-    internalQuery = query._query;
+    const query2 = cast(reference, Query);
+    firestore = cast(query2.firestore, Firestore);
+    internalQuery = query2._query;
     const userDataWriter = new ExpUserDataWriter(firestore);
     observer = {
       next: (snapshot) => {
         if (args[currArg]) {
-          args[currArg](new QuerySnapshot(firestore, userDataWriter, query, snapshot));
+          args[currArg](new QuerySnapshot(firestore, userDataWriter, query2, snapshot));
         }
       },
       error: args[currArg + 1],
@@ -36589,6 +36832,9 @@ function validateReference(documentRef, firestore) {
 function deleteField() {
   return new DeleteFieldValueImpl("deleteField");
 }
+function serverTimestamp() {
+  return new ServerTimestampFieldValueImpl("serverTimestamp");
+}
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -36697,16 +36943,48 @@ function createSdkFirebaseApi(options) {
       resolve();
     });
   });
+  let reads = 0;
+  const billed = (n) => reads += Math.max(n, 1);
+  const toDoc = (id, raw) => splitTs(id, fromFirestore(raw));
+  const since = (name2, ms) => query(collection(db, name2), where(TS_FIELD, ">", Timestamp.fromMillis(ms)));
+  const writeValue = (v) => v === DELETE_FIELD ? deleteField() : v === SERVER_TIMESTAMP ? serverTimestamp() : v;
   return {
     ...options.storageBucket ? { storage: sdkStorage(app) } : {},
+    readCount: () => reads,
     async listCollection(name2) {
       const snap = await getDocs(collection(db, name2));
-      return snap.docs.map((d) => ({ id: d.id, data: fromFirestore(d.data()) }));
+      billed(snap.size);
+      return snap.docs.map((d) => toDoc(d.id, d.data()));
+    },
+    async listSince(name2, ms) {
+      const snap = await getDocs(since(name2, ms));
+      billed(snap.size);
+      return snap.docs.map((d) => toDoc(d.id, d.data()));
     },
     watchCollection(name2, onDocs, onError) {
       return onSnapshot(
         collection(db, name2),
-        (snap) => onDocs(snap.docs.map((d) => ({ id: d.id, data: fromFirestore(d.data()) }))),
+        (snap) => {
+          if (!snap.metadata.fromCache) billed(snap.docChanges().length);
+          onDocs(snap.docs.map((d) => toDoc(d.id, d.data())));
+        },
+        onError
+      );
+    },
+    watchSince(name2, ms, onChanges, onError) {
+      return onSnapshot(
+        since(name2, ms),
+        (snap) => {
+          if (!snap.metadata.fromCache) billed(snap.docChanges().length);
+          const upserts = [];
+          const removed = [];
+          for (const ch of snap.docChanges()) {
+            if (ch.doc.metadata.hasPendingWrites) continue;
+            if (ch.type === "removed") removed.push(ch.doc.id);
+            else upserts.push(toDoc(ch.doc.id, ch.doc.data()));
+          }
+          if (upserts.length || removed.length) onChanges({ upserts, removed });
+        },
         onError
       );
     },
@@ -36716,15 +36994,16 @@ function createSdkFirebaseApi(options) {
     },
     async commit(ops) {
       const batch = writeBatch(db);
-      for (const op of ops) {
+      for (const op of withChangeTracking(ops)) {
         const ref = doc(db, op.collection, op.id);
-        if (op.type === "set") batch.set(ref, op.data);
-        else if (op.type === "delete") batch.delete(ref);
-        else {
-          const data = {};
-          for (const [k, v] of Object.entries(op.data)) data[k] = v === DELETE_FIELD ? deleteField() : v;
-          batch.update(ref, data);
+        if (op.type === "delete") {
+          batch.delete(ref);
+          continue;
         }
+        const data = {};
+        for (const [k, v] of Object.entries(op.data)) data[k] = writeValue(v);
+        if (op.type === "set") batch.set(ref, data);
+        else batch.update(ref, data);
       }
       await batch.commit();
     },