@firebase/firestore 3.4.3 → 3.4.4-canary.aaeab08ac

package/dist/index.node.mjs

@@ -8,7 +8,7 @@ import { credentials, loadPackageDefinition, Metadata } from '@grpc/grpc-js';
 import { fromJSON } from '@grpc/proto-loader';
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.3";
+const version$1 = "3.4.4-canary.aaeab08ac";
 
 /**
  * @license
@@ -61,7 +61,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.6.3";
+const version = "9.6.5-canary.aaeab08ac";
 
 /**
  * @license
@@ -3445,6 +3445,9 @@ class DocumentKey {
     static fromName(name) {
         return new DocumentKey(ResourcePath.fromString(name).popFirst(5));
     }
+    static empty() {
+        return new DocumentKey(ResourcePath.emptyPath());
+    }
     /** Returns true if the document is in the specified collectionId. */
     hasCollectionId(collectionId) {
         return (this.path.length >= 2 &&
@@ -4093,10 +4096,11 @@ function extractFieldMask(value) {
  * from all views.
  */
 class MutableDocument {
-    constructor(key, documentType, version, data, documentState) {
+    constructor(key, documentType, version, readTime, data, documentState) {
         this.key = key;
         this.documentType = documentType;
         this.version = version;
+        this.readTime = readTime;
         this.data = data;
         this.documentState = documentState;
     }
@@ -4105,18 +4109,18 @@ class MutableDocument {
      * base document for mutations.
      */
     static newInvalidDocument(documentKey) {
-        return new MutableDocument(documentKey, 0 /* INVALID */, SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
+        return new MutableDocument(documentKey, 0 /* INVALID */, SnapshotVersion.min(), SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
     }
     /**
      * Creates a new document that is known to exist with the given data at the
      * given version.
      */
     static newFoundDocument(documentKey, version, value) {
-        return new MutableDocument(documentKey, 1 /* FOUND_DOCUMENT */, version, value, 0 /* SYNCED */);
+        return new MutableDocument(documentKey, 1 /* FOUND_DOCUMENT */, version, SnapshotVersion.min(), value, 0 /* SYNCED */);
     }
     /** Creates a new document that is known to not exist at the given version. */
     static newNoDocument(documentKey, version) {
-        return new MutableDocument(documentKey, 2 /* NO_DOCUMENT */, version, ObjectValue.empty(), 0 /* SYNCED */);
+        return new MutableDocument(documentKey, 2 /* NO_DOCUMENT */, version, SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
     }
     /**
      * Creates a new document that is known to exist at the given version but
@@ -4124,7 +4128,7 @@ class MutableDocument {
      * base document).
      */
     static newUnknownDocument(documentKey, version) {
-        return new MutableDocument(documentKey, 3 /* UNKNOWN_DOCUMENT */, version, ObjectValue.empty(), 2 /* HAS_COMMITTED_MUTATIONS */);
+        return new MutableDocument(documentKey, 3 /* UNKNOWN_DOCUMENT */, version, SnapshotVersion.min(), ObjectValue.empty(), 2 /* HAS_COMMITTED_MUTATIONS */);
     }
     /**
      * Changes the document type to indicate that it exists and that its version
@@ -4168,6 +4172,10 @@ class MutableDocument {
         this.documentState = 1 /* HAS_LOCAL_MUTATIONS */;
         return this;
     }
+    setReadTime(readTime) {
+        this.readTime = readTime;
+        return this;
+    }
     get hasLocalMutations() {
         return this.documentState === 1 /* HAS_LOCAL_MUTATIONS */;
     }
@@ -4198,7 +4206,7 @@ class MutableDocument {
             this.data.isEqual(other.data));
     }
     mutableCopy() {
-        return new MutableDocument(this.key, this.documentType, this.version, this.data.clone(), this.documentState);
+        return new MutableDocument(this.key, this.documentType, this.version, this.readTime, this.data.clone(), this.documentState);
     }
     toString() {
         return (`Document(${this.key}, ${this.version}, ${JSON.stringify(this.data.value)}, ` +
@@ -7068,6 +7076,7 @@ class WatchChangeAggregator {
                 resolvedLimboDocuments = resolvedLimboDocuments.add(key);
             }
         });
+        this.pendingDocumentUpdates.forEach((_, doc) => doc.setReadTime(snapshotVersion));
         const remoteEvent = new RemoteEvent(snapshotVersion, targetChanges, this.pendingTargetResets, this.pendingDocumentUpdates, resolvedLimboDocuments);
         this.pendingDocumentUpdates = mutableDocumentMap();
         this.pendingDocumentTargetMapping = documentTargetMap();
@@ -8188,29 +8197,34 @@ class LocalSerializer {
 }
 /** Decodes a remote document from storage locally to a Document. */
 function fromDbRemoteDocument(localSerializer, remoteDoc) {
+    let doc;
     if (remoteDoc.document) {
-        return fromDocument(localSerializer.remoteSerializer, remoteDoc.document, !!remoteDoc.hasCommittedMutations);
+        doc = fromDocument(localSerializer.remoteSerializer, remoteDoc.document, !!remoteDoc.hasCommittedMutations);
     }
     else if (remoteDoc.noDocument) {
         const key = DocumentKey.fromSegments(remoteDoc.noDocument.path);
         const version = fromDbTimestamp(remoteDoc.noDocument.readTime);
-        const document = MutableDocument.newNoDocument(key, version);
-        return remoteDoc.hasCommittedMutations
-            ? document.setHasCommittedMutations()
-            : document;
+        doc = MutableDocument.newNoDocument(key, version);
+        if (remoteDoc.hasCommittedMutations) {
+            doc.setHasCommittedMutations();
+        }
     }
     else if (remoteDoc.unknownDocument) {
         const key = DocumentKey.fromSegments(remoteDoc.unknownDocument.path);
         const version = fromDbTimestamp(remoteDoc.unknownDocument.version);
-        return MutableDocument.newUnknownDocument(key, version);
+        doc = MutableDocument.newUnknownDocument(key, version);
     }
     else {
         return fail();
     }
+    if (remoteDoc.readTime) {
+        doc.setReadTime(fromDbTimestampKey(remoteDoc.readTime));
+    }
+    return doc;
 }
 /** Encodes a document for storage locally. */
-function toDbRemoteDocument(localSerializer, document, readTime) {
-    const dbReadTime = toDbTimestampKey(readTime);
+function toDbRemoteDocument(localSerializer, document) {
+    const dbReadTime = toDbTimestampKey(document.readTime);
     const parentPath = document.key.path.popLast().toArray();
     if (document.isFoundDocument()) {
         const doc = toDocument(localSerializer.remoteSerializer, document);
@@ -8221,10 +8235,10 @@ function toDbRemoteDocument(localSerializer, document, readTime) {
     }
     else if (document.isNoDocument()) {
         const path = document.key.path.toArray();
-        const readTime = toDbTimestamp(document.version);
+        const version = toDbTimestamp(document.version);
         const hasCommittedMutations = document.hasCommittedMutations;
         return new DbRemoteDocument(
-        /* unknownDocument= */ null, new DbNoDocument(path, readTime), 
+        /* unknownDocument= */ null, new DbNoDocument(path, version), 
         /* document= */ null, hasCommittedMutations, dbReadTime, parentPath);
     }
     else if (document.isUnknownDocument()) {
@@ -9753,7 +9767,7 @@ class IndexedDbLruDelegateImpl {
                         // Our size accounting requires us to read all documents before
                         // removing them.
                         return changeBuffer.getEntry(txn, docKey).next(() => {
-                            changeBuffer.removeEntry(docKey);
+                            changeBuffer.removeEntry(docKey, SnapshotVersion.min());
                             return documentTargetStore(txn).delete(sentinelKey$1(docKey));
                         });
                     }
@@ -9966,27 +9980,19 @@ class ObjectMap {
  */
 class RemoteDocumentChangeBuffer {
     constructor() {
-        // A mapping of document key to the new cache entry that should be written (or null if any
-        // existing cache entry should be removed).
+        // A mapping of document key to the new cache entry that should be written.
         this.changes = new ObjectMap(key => key.toString(), (l, r) => l.isEqual(r));
         this.changesApplied = false;
     }
-    getReadTime(key) {
-        const change = this.changes.get(key);
-        if (change) {
-            return change.readTime;
-        }
-        return SnapshotVersion.min();
-    }
     /**
      * Buffers a `RemoteDocumentCache.addEntry()` call.
      *
      * You can only modify documents that have already been retrieved via
      * `getEntry()/getEntries()` (enforced via IndexedDbs `apply()`).
      */
-    addEntry(document, readTime) {
+    addEntry(document) {
         this.assertNotApplied();
-        this.changes.set(document.key, { document, readTime });
+        this.changes.set(document.key, document);
     }
     /**
      * Buffers a `RemoteDocumentCache.removeEntry()` call.
@@ -9994,12 +10000,9 @@ class RemoteDocumentChangeBuffer {
      * You can only remove documents that have already been retrieved via
      * `getEntry()/getEntries()` (enforced via IndexedDbs `apply()`).
      */
-    removeEntry(key, readTime = null) {
+    removeEntry(key, readTime) {
         this.assertNotApplied();
-        this.changes.set(key, {
-            document: MutableDocument.newInvalidDocument(key),
-            readTime
-        });
+        this.changes.set(key, MutableDocument.newInvalidDocument(key).setReadTime(readTime));
     }
     /**
      * Looks up an entry in the cache. The buffered changes will first be checked,
@@ -10016,7 +10019,7 @@ class RemoteDocumentChangeBuffer {
         this.assertNotApplied();
         const bufferedEntry = this.changes.get(documentKey);
         if (bufferedEntry !== undefined) {
-            return PersistencePromise.resolve(bufferedEntry.document);
+            return PersistencePromise.resolve(bufferedEntry);
         }
         else {
             return this.getFromCache(transaction, documentKey);
@@ -10227,7 +10230,7 @@ class IndexedDbRemoteDocumentCacheImpl {
             if (key.length !== immediateChildrenPathLength) {
                 return;
             }
-            const document = fromDbRemoteDocument(this.serializer, dbRemoteDoc);
+            const document = this.maybeDecodeDocument(DocumentKey.fromSegments(key), dbRemoteDoc);
             if (!query.path.isPrefixOf(document.key.path)) {
                 control.done();
             }
@@ -10255,8 +10258,8 @@ class IndexedDbRemoteDocumentCacheImpl {
         return documentGlobalStore(txn).put(DbRemoteDocumentGlobal.key, metadata);
     }
     /**
-     * Decodes `remoteDoc` and returns the document (or null, if the document
-     * corresponds to the format used for sentinel deletes).
+     * Decodes `dbRemoteDoc` and returns the document (or an invalid document if
+     * the document corresponds to the format used for sentinel deletes).
      */
     maybeDecodeDocument(documentKey, dbRemoteDoc) {
         if (dbRemoteDoc) {
@@ -10350,8 +10353,8 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
         let collectionParents = new SortedSet((l, r) => primitiveComparator(l.canonicalString(), r.canonicalString()));
         this.changes.forEach((key, documentChange) => {
             const previousSize = this.documentSizes.get(key);
-            if (documentChange.document.isValidDocument()) {
-                const doc = toDbRemoteDocument(this.documentCache.serializer, documentChange.document, this.getReadTime(key));
+            if (documentChange.isValidDocument()) {
+                const doc = toDbRemoteDocument(this.documentCache.serializer, documentChange);
                 collectionParents = collectionParents.add(key.path.popLast());
                 const size = dbDocumentSize(doc);
                 sizeDelta += size - previousSize;
@@ -10364,7 +10367,7 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
                     // RemoteDocumentCache. This entry is represented by a NoDocument
                     // with a version of 0 and ignored by `maybeDecodeDocument()` but
                     // preserved in `getNewDocumentChanges()`.
-                    const deletedDoc = toDbRemoteDocument(this.documentCache.serializer, MutableDocument.newNoDocument(key, SnapshotVersion.min()), this.getReadTime(key));
+                    const deletedDoc = toDbRemoteDocument(this.documentCache.serializer, documentChange.convertToNoDocument(SnapshotVersion.min()));
                     promises.push(this.documentCache.addEntry(transaction, key, deletedDoc));
                 }
                 else {
@@ -11951,14 +11954,14 @@ function localStoreApplyRemoteEventToLocalCache(localStore, remoteEvent) {
             }
         });
         let changedDocs = mutableDocumentMap();
-        remoteEvent.documentUpdates.forEach((key, doc) => {
+        remoteEvent.documentUpdates.forEach(key => {
             if (remoteEvent.resolvedLimboDocuments.has(key)) {
                 promises.push(localStoreImpl.persistence.referenceDelegate.updateLimboDocument(txn, key));
             }
         });
         // Each loop iteration only affects its "own" doc, so it's safe to get all the remote
         // documents in advance in a single call.
-        promises.push(populateDocumentChangeBuffer(txn, documentBuffer, remoteEvent.documentUpdates, remoteVersion, undefined).next(result => {
+        promises.push(populateDocumentChangeBuffer(txn, documentBuffer, remoteEvent.documentUpdates).next(result => {
             changedDocs = result;
         }));
         // HACK: The only reason we allow a null snapshot version is so that we
@@ -11999,17 +12002,13 @@ function localStoreApplyRemoteEventToLocalCache(localStore, remoteEvent) {
  * Note: this function will use `documentVersions` if it is defined;
  * when it is not defined, resorts to `globalVersion`.
  */
-function populateDocumentChangeBuffer(txn, documentBuffer, documents, globalVersion, 
-// TODO(wuandy): We could add `readTime` to MaybeDocument instead to remove
-// this parameter.
-documentVersions) {
+function populateDocumentChangeBuffer(txn, documentBuffer, documents) {
     let updatedKeys = documentKeySet();
     documents.forEach(k => (updatedKeys = updatedKeys.add(k)));
     return documentBuffer.getEntries(txn, updatedKeys).next(existingDocs => {
         let changedDocs = mutableDocumentMap();
         documents.forEach((key, doc) => {
             const existingDoc = existingDocs.get(key);
-            const docReadTime = (documentVersions === null || documentVersions === void 0 ? void 0 : documentVersions.get(key)) || globalVersion;
             // Note: The order of the steps below is important, since we want
             // to ensure that rejected limbo resolutions (which fabricate
             // NoDocuments with SnapshotVersion.min()) never add documents to
@@ -12018,14 +12017,14 @@ documentVersions) {
                 // NoDocuments with SnapshotVersion.min() are used in manufactured
                 // events. We remove these documents from cache since we lost
                 // access.
-                documentBuffer.removeEntry(key, docReadTime);
+                documentBuffer.removeEntry(key, doc.readTime);
                 changedDocs = changedDocs.insert(key, doc);
             }
             else if (!existingDoc.isValidDocument() ||
                 doc.version.compareTo(existingDoc.version) > 0 ||
                 (doc.version.compareTo(existingDoc.version) === 0 &&
                     existingDoc.hasPendingWrites)) {
-                documentBuffer.addEntry(doc, docReadTime);
+                documentBuffer.addEntry(doc);
                 changedDocs = changedDocs.insert(key, doc);
             }
             else {
@@ -12279,7 +12278,8 @@ function applyWriteToRemoteDocuments(localStoreImpl, txn, batchResult, documentB
                     // We use the commitVersion as the readTime rather than the
                     // document's updateTime since the updateTime is not advanced
                     // for updates that do not modify the underlying document.
-                    documentBuffer.addEntry(doc, batchResult.commitVersion);
+                    doc.setReadTime(batchResult.commitVersion);
+                    documentBuffer.addEntry(doc);
                 }
             }
         });
@@ -12380,14 +12380,14 @@ async function localStoreApplyBundledDocuments(localStore, bundleConverter, docu
     const localStoreImpl = debugCast(localStore);
     let documentKeys = documentKeySet();
     let documentMap = mutableDocumentMap();
-    let versionMap = documentVersionMap();
     for (const bundleDoc of documents) {
         const documentKey = bundleConverter.toDocumentKey(bundleDoc.metadata.name);
         if (bundleDoc.document) {
             documentKeys = documentKeys.add(documentKey);
         }
-        documentMap = documentMap.insert(documentKey, bundleConverter.toMutableDocument(bundleDoc));
-        versionMap = versionMap.insert(documentKey, bundleConverter.toSnapshotVersion(bundleDoc.metadata.readTime));
+        const doc = bundleConverter.toMutableDocument(bundleDoc);
+        doc.setReadTime(bundleConverter.toSnapshotVersion(bundleDoc.metadata.readTime));
+        documentMap = documentMap.insert(documentKey, doc);
     }
     const documentBuffer = localStoreImpl.remoteDocuments.newChangeBuffer({
         trackRemovals: true // Make sure document removals show up in `getNewDocumentChanges()`
@@ -12396,7 +12396,7 @@ async function localStoreApplyBundledDocuments(localStore, bundleConverter, docu
     // they will not get garbage collected right away.
     const umbrellaTargetData = await localStoreAllocateTarget(localStoreImpl, umbrellaTarget(bundleName));
     return localStoreImpl.persistence.runTransaction('Apply bundle documents', 'readwrite', txn => {
-        return populateDocumentChangeBuffer(txn, documentBuffer, documentMap, SnapshotVersion.min(), versionMap)
+        return populateDocumentChangeBuffer(txn, documentBuffer, documentMap)
             .next(changedDocs => {
             documentBuffer.apply(txn);
             return changedDocs;
@@ -12877,15 +12877,14 @@ class MemoryRemoteDocumentCacheImpl {
      * All calls of `addEntry`  are required to go through the RemoteDocumentChangeBuffer
      * returned by `newChangeBuffer()`.
      */
-    addEntry(transaction, doc, readTime) {
+    addEntry(transaction, doc) {
         const key = doc.key;
         const entry = this.docs.get(key);
         const previousSize = entry ? entry.size : 0;
         const currentSize = this.sizer(doc);
         this.docs = this.docs.insert(key, {
             document: doc.mutableCopy(),
-            size: currentSize,
-            readTime
+            size: currentSize
         });
         this.size += currentSize - previousSize;
         return this.indexManager.addToCollectionParentIndex(transaction, key.path.popLast());
@@ -12926,11 +12925,11 @@ class MemoryRemoteDocumentCacheImpl {
         const prefix = new DocumentKey(query.path.child(''));
         const iterator = this.docs.getIteratorFrom(prefix);
         while (iterator.hasNext()) {
-            const { key, value: { document, readTime } } = iterator.getNext();
+            const { key, value: { document } } = iterator.getNext();
             if (!query.path.isPrefixOf(key.path)) {
                 break;
             }
-            if (readTime.compareTo(sinceReadTime) <= 0) {
+            if (document.readTime.compareTo(sinceReadTime) <= 0) {
                 continue;
             }
             if (!queryMatches(query, document)) {
@@ -12974,8 +12973,8 @@ class MemoryRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
     applyChanges(transaction) {
         const promises = [];
         this.changes.forEach((key, doc) => {
-            if (doc.document.isValidDocument()) {
-                promises.push(this.documentCache.addEntry(transaction, doc.document, this.getReadTime(key)));
+            if (doc.isValidDocument()) {
+                promises.push(this.documentCache.addEntry(transaction, doc));
             }
             else {
                 this.documentCache.removeEntry(key);
@@ -13288,7 +13287,7 @@ class MemoryEagerDelegate {
             const key = DocumentKey.fromPath(path);
             return this.isReferenced(txn, key).next(isReferenced => {
                 if (!isReferenced) {
-                    changeBuffer.removeEntry(key);
+                    changeBuffer.removeEntry(key, SnapshotVersion.min());
                 }
             });
         }).next(() => {
@@ -17068,6 +17067,40 @@ const nested = {
 								id: 2
 							}
 						}
+					},
+					methodSignature: {
+						rule: "repeated",
+						type: "string",
+						id: 1051,
+						extend: "google.protobuf.MethodOptions"
+					},
+					defaultHost: {
+						type: "string",
+						id: 1049,
+						extend: "google.protobuf.ServiceOptions"
+					},
+					oauthScopes: {
+						type: "string",
+						id: 1050,
+						extend: "google.protobuf.ServiceOptions"
+					},
+					fieldBehavior: {
+						rule: "repeated",
+						type: "google.api.FieldBehavior",
+						id: 1052,
+						extend: "google.protobuf.FieldOptions"
+					},
+					FieldBehavior: {
+						values: {
+							FIELD_BEHAVIOR_UNSPECIFIED: 0,
+							OPTIONAL: 1,
+							REQUIRED: 2,
+							OUTPUT_ONLY: 3,
+							INPUT_ONLY: 4,
+							IMMUTABLE: 5,
+							UNORDERED_LIST: 6,
+							NON_EMPTY_DEFAULT: 7
+						}
 					}
 				}
 			},
@@ -20311,6 +20344,9 @@ async function syncEngineRejectListen(syncEngine, targetId, err) {
         // store to purge a document. However, it would be tricky to keep all of
         // the local store's invariants with another method.
         let documentUpdates = new SortedMap(DocumentKey.comparator);
+        // TODO(b/217189216): This limbo document should ideally have a read time,
+        // so that it is picked up by any read-time based scans. The backend,
+        // however, does not send a read time for target removals.
         documentUpdates = documentUpdates.insert(limboKey, MutableDocument.newNoDocument(limboKey, SnapshotVersion.min()));
         const resolvedLimboDocuments = documentKeySet().add(limboKey);
         const event = new RemoteEvent(SnapshotVersion.min(), 
@@ -21878,13 +21914,16 @@ class FirestoreClient {
         this.user = User.UNAUTHENTICATED;
         this.clientId = AutoId.newId();
         this.authCredentialListener = () => Promise.resolve();
+        this.appCheckCredentialListener = () => Promise.resolve();
         this.authCredentials.start(asyncQueue, async (user) => {
             logDebug(LOG_TAG$2, 'Received user=', user.uid);
             await this.authCredentialListener(user);
             this.user = user;
         });
-        // Register an empty credentials change listener to activate token refresh.
-        this.appCheckCredentials.start(asyncQueue, () => Promise.resolve());
+        this.appCheckCredentials.start(asyncQueue, newAppCheckToken => {
+            logDebug(LOG_TAG$2, 'Received new app check token=', newAppCheckToken);
+            return this.appCheckCredentialListener(newAppCheckToken, this.user);
+        });
     }
     async getConfiguration() {
         return {
@@ -21900,6 +21939,9 @@ class FirestoreClient {
     setCredentialChangeListener(listener) {
         this.authCredentialListener = listener;
     }
+    setAppCheckTokenChangeListener(listener) {
+        this.appCheckCredentialListener = listener;
+    }
     /**
      * Checks that the client has not been terminated. Ensures that other methods on
      * this class cannot be called after the client is terminated.
@@ -21961,6 +22003,7 @@ async function setOnlineComponentProvider(client, onlineComponentProvider) {
     // The CredentialChangeListener of the online component provider takes
     // precedence over the offline component provider.
     client.setCredentialChangeListener(user => remoteStoreHandleCredentialChange(onlineComponentProvider.remoteStore, user));
+    client.setAppCheckTokenChangeListener((_, user) => remoteStoreHandleCredentialChange(onlineComponentProvider.remoteStore, user));
     client.onlineComponents = onlineComponentProvider;
 }
 async function ensureOfflineComponents(client) {
@@ -23513,13 +23556,13 @@ function terminate(firestore) {
 /**
  * Loads a Firestore bundle into the local cache.
  *
- * @param firestore - The {@link Firestore} instance to load bundles for for.
- * @param bundleData - An object representing the bundle to be loaded. Valid objects are
- *   `ArrayBuffer`, `ReadableStream<Uint8Array>` or `string`.
+ * @param firestore - The {@link Firestore} instance to load bundles for.
+ * @param bundleData - An object representing the bundle to be loaded. Valid
+ * objects are `ArrayBuffer`, `ReadableStream<Uint8Array>` or `string`.
  *
- * @returns
- *   A `LoadBundleTask` object, which notifies callers with progress updates, and completion
- *   or error events. It can be used as a `Promise<LoadBundleTaskProgress>`.
+ * @returns A `LoadBundleTask` object, which notifies callers with progress
+ * updates, and completion or error events. It can be used as a
+ * `Promise<LoadBundleTaskProgress>`.
  */
 function loadBundle(firestore, bundleData) {
     firestore = cast(firestore, Firestore);
@@ -23529,11 +23572,16 @@ function loadBundle(firestore, bundleData) {
     return resultTask;
 }
 /**
- * Reads a Firestore {@link Query} from local cache, identified by the given name.
+ * Reads a Firestore {@link Query} from local cache, identified by the given
+ * name.
  *
  * The named queries are packaged  into bundles on the server side (along
- * with resulting documents), and loaded to local cache using `loadBundle`. Once in local
- * cache, use this method to extract a {@link Query} by name.
+ * with resulting documents), and loaded to local cache using `loadBundle`. Once
+ * in local cache, use this method to extract a {@link Query} by name.
+ *
+ * @param firestore - The {@link Firestore} instance to read the query from.
+ * @param name - The name of the query.
+ * @returns A `Promise` that is resolved with the Query or `null`.
  */
 function namedQuery(firestore, name) {
     firestore = cast(firestore, Firestore);
@@ -26223,6 +26271,190 @@ function writeBatch(firestore) {
     return new WriteBatch(firestore, mutations => executeWrite(firestore, mutations));
 }
 
+/**
+ * @license
+ * Copyright 2021 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.
+ */
+/**
+ * The initial mutation batch id for each index. Gets updated during index
+ * backfill.
+ */
+const INITIAL_LARGEST_BATCH_ID = -1;
+/**
+ * The initial sequence number for each index. Gets updated during index
+ * backfill.
+ */
+const INITIAL_SEQUENCE_NUMBER = 0;
+/**
+ * An index definition for field indexes in Firestore.
+ *
+ * Every index is associated with a collection. The definition contains a list
+ * of fields and their index kind (which can be `ASCENDING`, `DESCENDING` or
+ * `CONTAINS` for ArrayContains/ArrayContainsAny queries).
+ *
+ * Unlike the backend, the SDK does not differentiate between collection or
+ * collection group-scoped indices. Every index can be used for both single
+ * collection and collection group queries.
+ */
+class FieldIndex {
+    constructor(
+    /**
+     * The index ID. Returns -1 if the index ID is not available (e.g. the index
+     * has not yet been persisted).
+     */
+    indexId, 
+    /** The collection ID this index applies to. */
+    collectionGroup, 
+    /** The field segments for this index. */
+    segments, 
+    /** Shows how up-to-date the index is for the current user. */
+    indexState) {
+        this.indexId = indexId;
+        this.collectionGroup = collectionGroup;
+        this.segments = segments;
+        this.indexState = indexState;
+    }
+}
+/** An ID for an index that has not yet been added to persistence.  */
+FieldIndex.UNKNOWN_ID = -1;
+/** An index component consisting of field path and index type.  */
+class IndexSegment {
+    constructor(
+    /** The field path of the component. */
+    fieldPath, 
+    /** The fields sorting order. */
+    kind) {
+        this.fieldPath = fieldPath;
+        this.kind = kind;
+    }
+}
+/**
+ * Stores the "high water mark" that indicates how updated the Index is for the
+ * current user.
+ */
+class IndexState {
+    constructor(
+    /**
+     * Indicates when the index was last updated (relative to other indexes).
+     */
+    sequenceNumber, 
+    /** The the latest indexed read time, document and batch id. */
+    offset) {
+        this.sequenceNumber = sequenceNumber;
+        this.offset = offset;
+    }
+    /** The state of an index that has not yet been backfilled. */
+    static empty() {
+        return new IndexState(INITIAL_SEQUENCE_NUMBER, IndexOffset.min());
+    }
+}
+/**
+ * Stores the latest read time, document and batch ID that were processed for an
+ * index.
+ */
+class IndexOffset {
+    constructor(
+    /**
+     * The latest read time version that has been indexed by Firestore for this
+     * field index.
+     */
+    readTime, 
+    /**
+     * The key of the last document that was indexed for this query. Use
+     * `DocumentKey.empty()` if no document has been indexed.
+     */
+    documentKey, 
+    /*
+     * The largest mutation batch id that's been processed by Firestore.
+     */
+    largestBatchId) {
+        this.readTime = readTime;
+        this.documentKey = documentKey;
+        this.largestBatchId = largestBatchId;
+    }
+    /** The state of an index that has not yet been backfilled. */
+    static min() {
+        return new IndexOffset(SnapshotVersion.min(), DocumentKey.empty(), INITIAL_LARGEST_BATCH_ID);
+    }
+}
+
+/**
+ * @license
+ * Copyright 2021 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 setIndexConfiguration(firestore, jsonOrConfiguration) {
+    firestore = cast(firestore, Firestore);
+    ensureFirestoreConfigured(firestore);
+    const indexConfiguration = typeof jsonOrConfiguration === 'string'
+        ? tryParseJson(jsonOrConfiguration)
+        : jsonOrConfiguration;
+    const parsedIndexes = [];
+    // PORTING NOTE: We don't return an error if the user has not enabled
+    // persistence since `enableIndexeddbPersistence()` can fail on the Web.
+    if (Array.isArray(indexConfiguration.indexes)) {
+        for (const index of indexConfiguration.indexes) {
+            const collectionGroup = tryGetString(index, 'collectionGroup');
+            const segments = [];
+            if (Array.isArray(index.fields)) {
+                for (const field of index.fields) {
+                    const fieldPathString = tryGetString(field, 'fieldPath');
+                    const fieldPath = fieldPathFromDotSeparatedString('setIndexConfiguration', fieldPathString);
+                    if (field.arrayConfig === 'CONTAINS') {
+                        segments.push(new IndexSegment(fieldPath, 2 /* CONTAINS */));
+                    }
+                    else if (field.order === 'ASCENDING') {
+                        segments.push(new IndexSegment(fieldPath, 0 /* ASCENDING */));
+                    }
+                    else if (field.order === 'DESCENDING') {
+                        segments.push(new IndexSegment(fieldPath, 1 /* DESCENDING */));
+                    }
+                }
+            }
+            parsedIndexes.push(new FieldIndex(FieldIndex.UNKNOWN_ID, collectionGroup, segments, IndexState.empty()));
+        }
+    }
+    // TODO(indexing): Configure indexes
+    return Promise.resolve();
+}
+function tryParseJson(json) {
+    try {
+        return JSON.parse(json);
+    }
+    catch (e) {
+        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Failed to parse JSON:' + e.message);
+    }
+}
+function tryGetString(data, property) {
+    if (typeof data[property] !== 'string') {
+        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Missing string value for: ' + property);
+    }
+    return data[property];
+}
+
 /**
  * @license
  * Copyright 2021 Google LLC
@@ -26241,5 +26473,5 @@ function writeBatch(firestore) {
  */
 registerFirestore('node');
 
-export { AbstractUserDataWriter, Bytes, CACHE_SIZE_UNLIMITED, CollectionReference, DocumentReference, DocumentSnapshot, FieldPath, FieldValue, Firestore, FirestoreError, GeoPoint, LoadBundleTask, Query, QueryConstraint, QueryDocumentSnapshot, QuerySnapshot, SnapshotMetadata, Timestamp, Transaction, WriteBatch, DatabaseId as _DatabaseId, DocumentKey as _DocumentKey, EmptyAppCheckTokenProvider as _EmptyAppCheckTokenProvider, EmptyAuthCredentialsProvider as _EmptyAuthCredentialsProvider, FieldPath$1 as _FieldPath, cast as _cast, debugAssert as _debugAssert, isBase64Available as _isBase64Available, logWarn as _logWarn, validateIsNotUsedTogether as _validateIsNotUsedTogether, addDoc, arrayRemove, arrayUnion, clearIndexedDbPersistence, collection, collectionGroup, connectFirestoreEmulator, deleteDoc, deleteField, disableNetwork, doc, documentId, enableIndexedDbPersistence, enableMultiTabIndexedDbPersistence, enableNetwork, endAt, endBefore, ensureFirestoreConfigured, executeWrite, getDoc, getDocFromCache, getDocFromServer, getDocs, getDocsFromCache, getDocsFromServer, getFirestore, increment, initializeFirestore, limit, limitToLast, loadBundle, namedQuery, onSnapshot, onSnapshotsInSync, orderBy, query, queryEqual, refEqual, runTransaction, serverTimestamp, setDoc, setLogLevel, snapshotEqual, startAfter, startAt, terminate, updateDoc, waitForPendingWrites, where, writeBatch };
+export { AbstractUserDataWriter, Bytes, CACHE_SIZE_UNLIMITED, CollectionReference, DocumentReference, DocumentSnapshot, FieldPath, FieldValue, Firestore, FirestoreError, GeoPoint, LoadBundleTask, Query, QueryConstraint, QueryDocumentSnapshot, QuerySnapshot, SnapshotMetadata, Timestamp, Transaction, WriteBatch, DatabaseId as _DatabaseId, DocumentKey as _DocumentKey, EmptyAppCheckTokenProvider as _EmptyAppCheckTokenProvider, EmptyAuthCredentialsProvider as _EmptyAuthCredentialsProvider, FieldPath$1 as _FieldPath, cast as _cast, debugAssert as _debugAssert, isBase64Available as _isBase64Available, logWarn as _logWarn, setIndexConfiguration as _setIndexConfiguration, validateIsNotUsedTogether as _validateIsNotUsedTogether, addDoc, arrayRemove, arrayUnion, clearIndexedDbPersistence, collection, collectionGroup, connectFirestoreEmulator, deleteDoc, deleteField, disableNetwork, doc, documentId, enableIndexedDbPersistence, enableMultiTabIndexedDbPersistence, enableNetwork, endAt, endBefore, ensureFirestoreConfigured, executeWrite, getDoc, getDocFromCache, getDocFromServer, getDocs, getDocsFromCache, getDocsFromServer, getFirestore, increment, initializeFirestore, limit, limitToLast, loadBundle, namedQuery, onSnapshot, onSnapshotsInSync, orderBy, query, queryEqual, refEqual, runTransaction, serverTimestamp, setDoc, setLogLevel, snapshotEqual, startAfter, startAt, terminate, updateDoc, waitForPendingWrites, where, writeBatch };
 //# sourceMappingURL=index.node.mjs.map