@firebase/firestore 3.4.3 → 3.4.4-canary.0482aa5b7

package/dist/index.node.cjs.js

@@ -12,7 +12,7 @@ var grpcJs = require('@grpc/grpc-js');
 var protoLoader = require('@grpc/proto-loader');
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.3";
+const version$1 = "3.4.4-canary.0482aa5b7";
 
 /**
  * @license
@@ -65,7 +65,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.0482aa5b7";
 
 /**
  * @license
@@ -1196,23 +1196,6 @@ function decodeResourcePath(path) {
     }
     return new ResourcePath(segments);
 }
-
-/**
- * @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.
- */
 /**
  * Schema Version for the Web client:
  * 1.  Initial version including Mutation Queue, Query Cache, and Remote
@@ -1231,6 +1214,7 @@ function decodeResourcePath(path) {
  *     an auto-incrementing ID. This is required for Index-Free queries.
  * 10. Rewrite the canonical IDs to the explicit Protobuf-based format.
  * 11. Add bundles and named_queries for bundle support.
+ * 12. Add indexing support.
  */
 const SCHEMA_VERSION = 11;
 /**
@@ -1757,9 +1741,7 @@ class DbClientMetadata {
 DbClientMetadata.store = 'clientMetadata';
 /** Keys are automatically assigned via the clientId properties. */
 DbClientMetadata.keyPath = 'clientId';
-/**
- * A object representing a bundle loaded by the SDK.
- */
+/** An object representing a bundle loaded by the SDK. */
 class DbBundle {
     constructor(
     /** The ID of the loaded bundle. */
@@ -1776,9 +1758,7 @@ class DbBundle {
 /** Name of the IndexedDb object store. */
 DbBundle.store = 'bundles';
 DbBundle.keyPath = 'bundleId';
-/**
- * A object representing a named query loaded by the SDK via a bundle.
- */
+/** An object representing a named query loaded by the SDK via a bundle. */
 class DbNamedQuery {
     constructor(
     /** The name of the query. */
@@ -1795,6 +1775,93 @@ class DbNamedQuery {
 /** Name of the IndexedDb object store. */
 DbNamedQuery.store = 'namedQueries';
 DbNamedQuery.keyPath = 'name';
+/** An object representing the global configuration for a field index. */
+class DbIndexConfiguration {
+    constructor(
+    /** The index id for this entry. */
+    indexId, 
+    /** The collection group this index belongs to. */
+    collectionGroup, 
+    /** The fields to index for this index. */
+    fields) {
+        this.indexId = indexId;
+        this.collectionGroup = collectionGroup;
+        this.fields = fields;
+    }
+}
+/** Name of the IndexedDb object store. */
+DbIndexConfiguration.store = 'indexConfiguration';
+DbIndexConfiguration.keyPath = 'indexId';
+/**
+ * An object describing how up-to-date the index backfill is for each user and
+ * index.
+ */
+class DbIndexState {
+    constructor(
+    /** The index id for this entry. */
+    indexId, 
+    /** The user id for this entry. */
+    uid, 
+    /**
+     * A number that indicates when the index was last updated (relative to
+     * other indexes).
+     */
+    sequenceNumber, 
+    /**
+     * The latest read time that has been indexed by Firestore for this field
+     * index. Set to `{seconds: 0, nanos: 0}` if no documents have been indexed.
+     */
+    readTime, 
+    /**
+     * The last document that has been indexed for this field index. Empty if
+     * no documents have been indexed.
+     */
+    documentKey, 
+    /**
+     * The largest mutation batch id that has been processed for this index. -1
+     * if no mutations have been indexed.
+     */
+    largestBatchId) {
+        this.indexId = indexId;
+        this.uid = uid;
+        this.sequenceNumber = sequenceNumber;
+        this.readTime = readTime;
+        this.documentKey = documentKey;
+        this.largestBatchId = largestBatchId;
+    }
+}
+/** Name of the IndexedDb object store. */
+DbIndexState.store = 'indexState';
+DbIndexState.keyPath = ['indexId', 'uid'];
+/** An object that stores the encoded entries for all documents and fields. */
+class DbIndexEntries {
+    constructor(
+    /** The index id for this entry. */
+    indexId, 
+    /** The user id for this entry. */
+    uid, 
+    /** The encoded array index value for this entry. */
+    arrayValue, 
+    /** The encoded directional value for equality and inequality filters. */
+    directionalValue, 
+    /** The document key this entry points to. */
+    documentKey) {
+        this.indexId = indexId;
+        this.uid = uid;
+        this.arrayValue = arrayValue;
+        this.directionalValue = directionalValue;
+        this.documentKey = documentKey;
+    }
+}
+/** Name of the IndexedDb object store. */
+DbIndexEntries.store = 'indexEntries';
+DbIndexEntries.keyPath = [
+    'indexId',
+    'uid',
+    'arrayValue',
+    'directionalValue',
+    'documentKey'
+];
 // Visible for testing
 const V1_STORES = [
     DbMutationQueue.store,
@@ -1809,7 +1876,6 @@ const V1_STORES = [
 // V2 is no longer usable (see comment at top of file)
 // Visible for testing
 const V3_STORES = V1_STORES;
-// Visible for testing
 // Note: DbRemoteDocumentChanges is no longer used and dropped with v9.
 const V4_STORES = [...V3_STORES, DbClientMetadata.store];
 // V5 does not change the set of stores.
@@ -1819,6 +1885,12 @@ const V8_STORES = [...V6_STORES, DbCollectionParent.store];
 // V9 does not change the set of stores.
 // V10 does not change the set of stores.
 const V11_STORES = [...V8_STORES, DbBundle.store, DbNamedQuery.store];
+[
+    ...V11_STORES,
+    DbIndexConfiguration.store,
+    DbIndexState.store,
+    DbIndexEntries.store
+];
 /**
  * The list of all default IndexedDB stores used throughout the SDK. This is
  * used when creating transactions so that access across all stores is done
@@ -3378,6 +3450,75 @@ function getLocalWriteTime(value) {
     return new Timestamp(localWriteTime.seconds, localWriteTime.nanos);
 }
 
+/**
+ * @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 DatabaseInfo {
+    /**
+     * Constructs a DatabaseInfo using the provided host, databaseId and
+     * persistenceKey.
+     *
+     * @param databaseId - The database to use.
+     * @param appId - The Firebase App Id.
+     * @param persistenceKey - A unique identifier for this Firestore's local
+     * storage (used in conjunction with the databaseId).
+     * @param host - The Firestore backend host to connect to.
+     * @param ssl - Whether to use SSL when connecting.
+     * @param forceLongPolling - Whether to use the forceLongPolling option
+     * when using WebChannel as the network transport.
+     * @param autoDetectLongPolling - Whether to use the detectBufferingProxy
+     * option when using WebChannel as the network transport.
+     * @param useFetchStreams Whether to use the Fetch API instead of
+     * XMLHTTPRequest
+     */
+    constructor(databaseId, appId, persistenceKey, host, ssl, forceLongPolling, autoDetectLongPolling, useFetchStreams) {
+        this.databaseId = databaseId;
+        this.appId = appId;
+        this.persistenceKey = persistenceKey;
+        this.host = host;
+        this.ssl = ssl;
+        this.forceLongPolling = forceLongPolling;
+        this.autoDetectLongPolling = autoDetectLongPolling;
+        this.useFetchStreams = useFetchStreams;
+    }
+}
+/** The default database name for a project. */
+const DEFAULT_DATABASE_NAME = '(default)';
+/**
+ * Represents the database ID a Firestore client is associated with.
+ * @internal
+ */
+class DatabaseId {
+    constructor(projectId, database) {
+        this.projectId = projectId;
+        this.database = database ? database : DEFAULT_DATABASE_NAME;
+    }
+    static empty() {
+        return new DatabaseId('', '');
+    }
+    get isDefaultDatabase() {
+        return this.database === DEFAULT_DATABASE_NAME;
+    }
+    isEqual(other) {
+        return (other instanceof DatabaseId &&
+            other.projectId === this.projectId &&
+            other.database === this.database);
+    }
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -3449,6 +3590,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 &&
@@ -4097,10 +4241,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;
     }
@@ -4109,18 +4254,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
@@ -4128,7 +4273,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
@@ -4172,6 +4317,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 */;
     }
@@ -4202,7 +4351,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)}, ` +
@@ -4225,6 +4374,125 @@ function compareDocumentsByField(field, d1, d2) {
     }
 }
 
+/**
+ * @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 2019 Google LLC
@@ -4268,27 +4536,29 @@ function newTarget(path, collectionGroup = null, orderBy = [], filters = [], lim
 function canonifyTarget(target) {
     const targetImpl = debugCast(target);
     if (targetImpl.memoizedCanonicalId === null) {
-        let canonicalId = targetImpl.path.canonicalString();
+        let str = targetImpl.path.canonicalString();
         if (targetImpl.collectionGroup !== null) {
-            canonicalId += '|cg:' + targetImpl.collectionGroup;
+            str += '|cg:' + targetImpl.collectionGroup;
         }
-        canonicalId += '|f:';
-        canonicalId += targetImpl.filters.map(f => canonifyFilter(f)).join(',');
-        canonicalId += '|ob:';
-        canonicalId += targetImpl.orderBy.map(o => canonifyOrderBy(o)).join(',');
+        str += '|f:';
+        str += targetImpl.filters.map(f => canonifyFilter(f)).join(',');
+        str += '|ob:';
+        str += targetImpl.orderBy.map(o => canonifyOrderBy(o)).join(',');
         if (!isNullOrUndefined(targetImpl.limit)) {
-            canonicalId += '|l:';
-            canonicalId += targetImpl.limit;
+            str += '|l:';
+            str += targetImpl.limit;
         }
         if (targetImpl.startAt) {
-            canonicalId += '|lb:';
-            canonicalId += canonifyBound(targetImpl.startAt);
+            str += '|lb:';
+            str += targetImpl.startAt.inclusive ? 'b:' : 'a:';
+            str += targetImpl.startAt.position.map(p => canonicalId(p)).join(',');
         }
         if (targetImpl.endAt) {
-            canonicalId += '|ub:';
-            canonicalId += canonifyBound(targetImpl.endAt);
+            str += '|ub:';
+            str += targetImpl.endAt.inclusive ? 'a:' : 'b:';
+            str += targetImpl.endAt.position.map(p => canonicalId(p)).join(',');
         }
-        targetImpl.memoizedCanonicalId = canonicalId;
+        targetImpl.memoizedCanonicalId = str;
     }
     return targetImpl.memoizedCanonicalId;
 }
@@ -4311,10 +4581,14 @@ function stringifyTarget(target) {
             .join(', ')}]`;
     }
     if (target.startAt) {
-        str += ', startAt: ' + canonifyBound(target.startAt);
+        str += ', startAt: ';
+        str += target.startAt.inclusive ? 'b:' : 'a:';
+        str += target.startAt.position.map(p => canonicalId(p)).join(',');
     }
     if (target.endAt) {
-        str += ', endAt: ' + canonifyBound(target.endAt);
+        str += ', endAt: ';
+        str += target.endAt.inclusive ? 'a:' : 'b:';
+        str += target.endAt.position.map(p => canonicalId(p)).join(',');
     }
     return `Target(${str})`;
 }
@@ -4349,7 +4623,7 @@ function targetEquals(left, right) {
     }
     return boundEquals(left.endAt, right.endAt);
 }
-function isDocumentTarget(target) {
+function targetIsDocumentTarget(target) {
     return (DocumentKey.isDocumentKey(target.path) &&
         target.collectionGroup === null &&
         target.filters.length === 0);
@@ -4552,17 +4826,11 @@ class ArrayContainsAnyFilter extends FieldFilter {
  * just after the provided values.
  */
 class Bound {
-    constructor(position, before) {
+    constructor(position, inclusive) {
         this.position = position;
-        this.before = before;
+        this.inclusive = inclusive;
     }
 }
-function canonifyBound(bound) {
-    // TODO(b/29183165): Make this collision robust.
-    return `${bound.before ? 'b' : 'a'}:${bound.position
-        .map(p => canonicalId(p))
-        .join(',')}`;
-}
 /**
  * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
  */
@@ -4582,11 +4850,7 @@ function stringifyOrderBy(orderBy) {
 function orderByEquals(left, right) {
     return left.dir === right.dir && left.field.isEqual(right.field);
 }
-/**
- * Returns true if a document sorts before a bound using the provided sort
- * order.
- */
-function sortsBeforeDocument(bound, orderBy, doc) {
+function boundCompareToDocument(bound, orderBy, doc) {
     let comparison = 0;
     for (let i = 0; i < bound.position.length; i++) {
         const orderByComponent = orderBy[i];
@@ -4605,7 +4869,23 @@ function sortsBeforeDocument(bound, orderBy, doc) {
             break;
         }
     }
-    return bound.before ? comparison <= 0 : comparison < 0;
+    return comparison;
+}
+/**
+ * Returns true if a document sorts after a bound using the provided sort
+ * order.
+ */
+function boundSortsAfterDocument(bound, orderBy, doc) {
+    const comparison = boundCompareToDocument(bound, orderBy, doc);
+    return bound.inclusive ? comparison >= 0 : comparison > 0;
+}
+/**
+ * Returns true if a document sorts before a bound using the provided sort
+ * order.
+ */
+function boundSortsBeforeDocument(bound, orderBy, doc) {
+    const comparison = boundCompareToDocument(bound, orderBy, doc);
+    return bound.inclusive ? comparison <= 0 : comparison < 0;
 }
 function boundEquals(left, right) {
     if (left === null) {
@@ -4614,7 +4894,7 @@ function boundEquals(left, right) {
     else if (right === null) {
         return false;
     }
-    if (left.before !== right.before ||
+    if (left.inclusive !== right.inclusive ||
         left.position.length !== right.position.length) {
         return false;
     }
@@ -4818,10 +5098,10 @@ function queryToTarget(query) {
             }
             // We need to swap the cursors to match the now-flipped query ordering.
             const startAt = queryImpl.endAt
-                ? new Bound(queryImpl.endAt.position, !queryImpl.endAt.before)
+                ? new Bound(queryImpl.endAt.position, !queryImpl.endAt.inclusive)
                 : null;
             const endAt = queryImpl.startAt
-                ? new Bound(queryImpl.startAt.position, !queryImpl.startAt.before)
+                ? new Bound(queryImpl.startAt.position, !queryImpl.startAt.inclusive)
                 : null;
             // Now return as a LimitType.First query.
             queryImpl.memoizedTarget = newTarget(queryImpl.path, queryImpl.collectionGroup, orderBys, queryImpl.filters, queryImpl.limit, startAt, endAt);
@@ -4909,11 +5189,11 @@ function queryMatchesFilters(query, doc) {
 /** Makes sure a document is within the bounds, if provided. */
 function queryMatchesBounds(query, doc) {
     if (query.startAt &&
-        !sortsBeforeDocument(query.startAt, queryOrderBy(query), doc)) {
+        !boundSortsBeforeDocument(query.startAt, queryOrderBy(query), doc)) {
         return false;
     }
     if (query.endAt &&
-        sortsBeforeDocument(query.endAt, queryOrderBy(query), doc)) {
+        !boundSortsAfterDocument(query.endAt, queryOrderBy(query), doc)) {
         return false;
     }
     return true;
@@ -6994,7 +7274,7 @@ class WatchChangeAggregator {
         const targetData = this.targetDataForActiveTarget(targetId);
         if (targetData) {
             const target = targetData.target;
-            if (isDocumentTarget(target)) {
+            if (targetIsDocumentTarget(target)) {
                 if (expectedCount === 0) {
                     // The existence filter told us the document does not exist. We deduce
                     // that this document does not exist and apply a deleted document to
@@ -7029,7 +7309,7 @@ class WatchChangeAggregator {
         this.targetStates.forEach((targetState, targetId) => {
             const targetData = this.targetDataForActiveTarget(targetId);
             if (targetData) {
-                if (targetState.current && isDocumentTarget(targetData.target)) {
+                if (targetState.current && targetIsDocumentTarget(targetData.target)) {
                     // Document queries for document that don't exist can produce an empty
                     // result set. To update our local cache, we synthesize a document
                     // delete if we have not previously received the document. This
@@ -7072,6 +7352,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();
@@ -7791,10 +8072,10 @@ function toQueryTarget(serializer, target) {
         result.structuredQuery.limit = limit;
     }
     if (target.startAt) {
-        result.structuredQuery.startAt = toCursor(target.startAt);
+        result.structuredQuery.startAt = toStartAtCursor(target.startAt);
     }
     if (target.endAt) {
-        result.structuredQuery.endAt = toCursor(target.endAt);
+        result.structuredQuery.endAt = toEndAtCursor(target.endAt);
     }
     return result;
 }
@@ -7827,11 +8108,11 @@ function convertQueryTargetToQuery(target) {
     }
     let startAt = null;
     if (query.startAt) {
-        startAt = fromCursor(query.startAt);
+        startAt = fromStartAtCursor(query.startAt);
     }
     let endAt = null;
     if (query.endAt) {
-        endAt = fromCursor(query.endAt);
+        endAt = fromEndAtCursor(query.endAt);
     }
     return newQuery(path, collectionGroup, orderBy, filterBy, limit, "F" /* First */, startAt, endAt);
 }
@@ -7864,7 +8145,7 @@ function toLabel(serializer, purpose) {
 function toTarget(serializer, targetData) {
     let result;
     const target = targetData.target;
-    if (isDocumentTarget(target)) {
+    if (targetIsDocumentTarget(target)) {
         result = { documents: toDocumentsTarget(serializer, target) };
     }
     else {
@@ -7922,16 +8203,27 @@ function toOrder(orderBys) {
 function fromOrder(orderBys) {
     return orderBys.map(order => fromPropertyOrder(order));
 }
-function toCursor(cursor) {
+function toStartAtCursor(cursor) {
+    return {
+        before: cursor.inclusive,
+        values: cursor.position
+    };
+}
+function toEndAtCursor(cursor) {
     return {
-        before: cursor.before,
+        before: !cursor.inclusive,
         values: cursor.position
     };
 }
-function fromCursor(cursor) {
-    const before = !!cursor.before;
+function fromStartAtCursor(cursor) {
+    const inclusive = !!cursor.before;
     const position = cursor.values || [];
-    return new Bound(position, before);
+    return new Bound(position, inclusive);
+}
+function fromEndAtCursor(cursor) {
+    const inclusive = !cursor.before;
+    const position = cursor.values || [];
+    return new Bound(position, inclusive);
 }
 // visible for testing
 function toDirection(dir) {
@@ -8192,29 +8484,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);
@@ -8225,10 +8522,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()) {
@@ -8309,7 +8606,7 @@ function toDbTarget(localSerializer, targetData) {
     const dbTimestamp = toDbTimestamp(targetData.snapshotVersion);
     const dbLastLimboFreeTimestamp = toDbTimestamp(targetData.lastLimboFreeSnapshotVersion);
     let queryProto;
-    if (isDocumentTarget(targetData.target)) {
+    if (targetIsDocumentTarget(targetData.target)) {
         queryProto = toDocumentsTarget(localSerializer.remoteSerializer, targetData.target);
     }
     else {
@@ -8479,6 +8776,38 @@ class MemoryIndexManager {
     getCollectionParents(transaction, collectionId) {
         return PersistencePromise.resolve(this.collectionParentIndex.getEntries(collectionId));
     }
+    addFieldIndex(transaction, index) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve();
+    }
+    deleteFieldIndex(transaction, index) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve();
+    }
+    getDocumentsMatchingTarget(transaction, fieldIndex, target) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve(documentKeySet());
+    }
+    getFieldIndex(transaction, target) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve(null);
+    }
+    getFieldIndexes(transaction, collectionGroup) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve([]);
+    }
+    getNextCollectionGroupToUpdate(transaction) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve(null);
+    }
+    updateCollectionGroup(transaction, collectionGroup, offset) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve();
+    }
+    updateIndexEntries(transaction, documents) {
+        // Field indices are not supported with memory persistence.
+        return PersistencePromise.resolve();
+    }
 }
 /**
  * Internal implementation of the collection-parent index exposed by MemoryIndexManager.
@@ -8587,6 +8916,38 @@ class IndexedDbIndexManager {
             return parentPaths;
         });
     }
+    addFieldIndex(transaction, index) {
+        // TODO(indexing): Implement
+        return PersistencePromise.resolve();
+    }
+    deleteFieldIndex(transaction, index) {
+        // TODO(indexing): Implement
+        return PersistencePromise.resolve();
+    }
+    getDocumentsMatchingTarget(transaction, fieldIndex, target) {
+        // TODO(indexing): Implement
+        return PersistencePromise.resolve(documentKeySet());
+    }
+    getFieldIndex(transaction, target) {
+        // TODO(indexing): Implement
+        return PersistencePromise.resolve(null);
+    }
+    getFieldIndexes(transaction, collectionGroup) {
+        // TODO(indexing): Implement
+        return PersistencePromise.resolve([]);
+    }
+    getNextCollectionGroupToUpdate(transaction) {
+        // TODO(indexing): Implement
+        return PersistencePromise.resolve(null);
+    }
+    updateCollectionGroup(transaction, collectionGroup, offset) {
+        // TODO(indexing): Implement
+        return PersistencePromise.resolve();
+    }
+    updateIndexEntries(transaction, documents) {
+        // TODO(indexing): Implement
+        return PersistencePromise.resolve();
+    }
 }
 /**
  * Helper to get a typed SimpleDbStore for the collectionParents
@@ -9757,7 +10118,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));
                         });
                     }
@@ -9970,27 +10331,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.
@@ -9998,12 +10351,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,
@@ -10020,7 +10370,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);
@@ -10231,7 +10581,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();
             }
@@ -10259,8 +10609,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) {
@@ -10354,8 +10704,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;
@@ -10368,7 +10718,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 {
@@ -10449,9 +10799,6 @@ class SchemaConverter {
      * and local feature development.
      */
     createOrUpgrade(db, txn, fromVersion, toVersion) {
-        hardAssert(fromVersion < toVersion &&
-            fromVersion >= 0 &&
-            toVersion <= SCHEMA_VERSION);
         const simpleDbTransaction = new SimpleDbTransaction('createOrUpgrade', txn);
         if (fromVersion < 1 && toVersion >= 1) {
             createPrimaryClientStore(db);
@@ -10518,6 +10865,11 @@ class SchemaConverter {
                 createNamedQueriesStore(db);
             });
         }
+        if (fromVersion < 12 && toVersion >= 12) {
+            p = p.next(() => {
+                createFieldIndex(db);
+            });
+        }
         return p;
     }
     addDocumentGlobal(txn) {
@@ -10724,6 +11076,17 @@ function createNamedQueriesStore(db) {
     db.createObjectStore(DbNamedQuery.store, {
         keyPath: DbNamedQuery.keyPath
     });
+}
+function createFieldIndex(db) {
+    db.createObjectStore(DbIndexConfiguration.store, {
+        keyPath: DbIndexConfiguration.keyPath
+    });
+    db.createObjectStore(DbIndexState.store, {
+        keyPath: DbIndexState.keyPath
+    });
+    db.createObjectStore(DbIndexEntries.store, {
+        keyPath: DbIndexEntries.keyPath
+    });
 }
 
 /**
@@ -11955,14 +12318,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
@@ -12003,17 +12366,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
@@ -12022,14 +12381,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 {
@@ -12283,7 +12642,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);
                 }
             }
         });
@@ -12384,14 +12744,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()`
@@ -12400,7 +12760,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;
@@ -12881,15 +13241,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());
@@ -12930,11 +13289,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)) {
@@ -12978,8 +13337,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);
@@ -13292,7 +13651,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(() => {
@@ -17072,6 +17431,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
+						}
 					}
 				}
 			},
@@ -20315,6 +20708,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(), 
@@ -21882,13 +22278,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 {
@@ -21904,6 +22303,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.
@@ -21965,6 +22367,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) {
@@ -22252,72 +22655,6 @@ function createBundleReader(data, serializer) {
     return newBundleReader(toByteStreamReader(content), serializer);
 }
 
-/**
- * @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 DatabaseInfo {
-    /**
-     * Constructs a DatabaseInfo using the provided host, databaseId and
-     * persistenceKey.
-     *
-     * @param databaseId - The database to use.
-     * @param appId - The Firebase App Id.
-     * @param persistenceKey - A unique identifier for this Firestore's local
-     * storage (used in conjunction with the databaseId).
-     * @param host - The Firestore backend host to connect to.
-     * @param ssl - Whether to use SSL when connecting.
-     * @param forceLongPolling - Whether to use the forceLongPolling option
-     * when using WebChannel as the network transport.
-     * @param autoDetectLongPolling - Whether to use the detectBufferingProxy
-     * option when using WebChannel as the network transport.
-     * @param useFetchStreams Whether to use the Fetch API instead of
-     * XMLHTTPRequest
-     */
-    constructor(databaseId, appId, persistenceKey, host, ssl, forceLongPolling, autoDetectLongPolling, useFetchStreams) {
-        this.databaseId = databaseId;
-        this.appId = appId;
-        this.persistenceKey = persistenceKey;
-        this.host = host;
-        this.ssl = ssl;
-        this.forceLongPolling = forceLongPolling;
-        this.autoDetectLongPolling = autoDetectLongPolling;
-        this.useFetchStreams = useFetchStreams;
-    }
-}
-/** The default database name for a project. */
-const DEFAULT_DATABASE_NAME = '(default)';
-/**
- * Represents the database ID a Firestore client is associated with.
- * @internal
- */
-class DatabaseId {
-    constructor(projectId, database) {
-        this.projectId = projectId;
-        this.database = database ? database : DEFAULT_DATABASE_NAME;
-    }
-    get isDefaultDatabase() {
-        return this.database === DEFAULT_DATABASE_NAME;
-    }
-    isEqual(other) {
-        return (other instanceof DatabaseId &&
-            other.projectId === this.projectId &&
-            other.database === this.database);
-    }
-}
-
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -23517,13 +23854,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);
@@ -23533,11 +23870,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);
@@ -24686,8 +25028,7 @@ class DocumentSnapshot extends DocumentSnapshot$1 {
         this.metadata = metadata;
     }
     /**
-     * Property of the `DocumentSnapshot` that signals whether or not the data
-     * exists. True if the document exists.
+     * Returns whether or not the data exists. True if the document exists.
      */
     exists() {
         return super.exists();
@@ -25061,51 +25402,53 @@ function limitToLast(limit) {
     return new QueryLimitConstraint('limitToLast', limit, "L" /* Last */);
 }
 class QueryStartAtConstraint extends QueryConstraint {
-    constructor(type, _docOrFields, _before) {
+    constructor(type, _docOrFields, _inclusive) {
         super();
         this.type = type;
         this._docOrFields = _docOrFields;
-        this._before = _before;
+        this._inclusive = _inclusive;
     }
     _apply(query) {
-        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._before);
+        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._inclusive);
         return new Query(query.firestore, query.converter, queryWithStartAt(query._query, bound));
     }
 }
 function startAt(...docOrFields) {
-    return new QueryStartAtConstraint('startAt', docOrFields, /*before=*/ true);
+    return new QueryStartAtConstraint('startAt', docOrFields, 
+    /*inclusive=*/ true);
 }
 function startAfter(...docOrFields) {
     return new QueryStartAtConstraint('startAfter', docOrFields, 
-    /*before=*/ false);
+    /*inclusive=*/ false);
 }
 class QueryEndAtConstraint extends QueryConstraint {
-    constructor(type, _docOrFields, _before) {
+    constructor(type, _docOrFields, _inclusive) {
         super();
         this.type = type;
         this._docOrFields = _docOrFields;
-        this._before = _before;
+        this._inclusive = _inclusive;
     }
     _apply(query) {
-        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._before);
+        const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._inclusive);
         return new Query(query.firestore, query.converter, queryWithEndAt(query._query, bound));
     }
 }
 function endBefore(...docOrFields) {
-    return new QueryEndAtConstraint('endBefore', docOrFields, /*before=*/ true);
+    return new QueryEndAtConstraint('endBefore', docOrFields, 
+    /*inclusive=*/ false);
 }
 function endAt(...docOrFields) {
-    return new QueryEndAtConstraint('endAt', docOrFields, /*before=*/ false);
+    return new QueryEndAtConstraint('endAt', docOrFields, /*inclusive=*/ true);
 }
 /** Helper function to create a bound from a document or fields */
-function newQueryBoundFromDocOrFields(query, methodName, docOrFields, before) {
+function newQueryBoundFromDocOrFields(query, methodName, docOrFields, inclusive) {
     docOrFields[0] = util$1.getModularInstance(docOrFields[0]);
     if (docOrFields[0] instanceof DocumentSnapshot$1) {
-        return newQueryBoundFromDocument(query._query, query.firestore._databaseId, methodName, docOrFields[0]._document, before);
+        return newQueryBoundFromDocument(query._query, query.firestore._databaseId, methodName, docOrFields[0]._document, inclusive);
     }
     else {
         const reader = newUserDataReader(query.firestore);
-        return newQueryBoundFromFields(query._query, query.firestore._databaseId, reader, methodName, docOrFields, before);
+        return newQueryBoundFromFields(query._query, query.firestore._databaseId, reader, methodName, docOrFields, inclusive);
     }
 }
 function newQueryFilter(query, methodName, dataReader, databaseId, fieldPath, op, value) {
@@ -25163,7 +25506,7 @@ function newQueryOrderBy(query, fieldPath, direction) {
  * of the query or if any of the fields in the order by are an uncommitted
  * server timestamp.
  */
-function newQueryBoundFromDocument(query, databaseId, methodName, doc, before) {
+function newQueryBoundFromDocument(query, databaseId, methodName, doc, inclusive) {
     if (!doc) {
         throw new FirestoreError(Code.NOT_FOUND, `Can't use a DocumentSnapshot that doesn't exist for ` +
             `${methodName}().`);
@@ -25200,12 +25543,12 @@ function newQueryBoundFromDocument(query, databaseId, methodName, doc, before) {
             }
         }
     }
-    return new Bound(components, before);
+    return new Bound(components, inclusive);
 }
 /**
  * Converts a list of field values to a `Bound` for the given query.
  */
-function newQueryBoundFromFields(query, databaseId, dataReader, methodName, values, before) {
+function newQueryBoundFromFields(query, databaseId, dataReader, methodName, values, inclusive) {
     // Use explicit order by's because it has to match the query the user made
     const orderBy = query.explicitOrderBy;
     if (values.length > orderBy.length) {
@@ -25242,7 +25585,7 @@ function newQueryBoundFromFields(query, databaseId, dataReader, methodName, valu
             components.push(wrapped);
         }
     }
-    return new Bound(components, before);
+    return new Bound(components, inclusive);
 }
 /**
  * Parses the given `documentIdValue` into a `ReferenceValue`, throwing
@@ -26227,6 +26570,71 @@ 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.
+ */
+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
@@ -26274,6 +26682,7 @@ exports._cast = cast;
 exports._debugAssert = debugAssert;
 exports._isBase64Available = isBase64Available;
 exports._logWarn = logWarn;
+exports._setIndexConfiguration = setIndexConfiguration;
 exports._validateIsNotUsedTogether = validateIsNotUsedTogether;
 exports.addDoc = addDoc;
 exports.arrayRemove = arrayRemove;