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

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @firebase/firestore
 
+## 3.4.4
+
+### Patch Changes
+
+- [`e28b0e413`](https://github.com/firebase/firebase-js-sdk/commit/e28b0e413decb115c846a7b5ed1e63dbf55c56ab) [#5902](https://github.com/firebase/firebase-js-sdk/pull/5902) (fixes [#5842](https://github.com/firebase/firebase-js-sdk/issues/5842)) - Fixed an AppCheck issue that caused Firestore listeners to stop working and
+  receive a "Permission Denied" error. This issue only occurred for AppCheck users
+  that set their expiration time to under an hour.
+
+* [`d612d6f6e`](https://github.com/firebase/firebase-js-sdk/commit/d612d6f6e4d3113d45427b7df68459c0a3e31a1f) [#5928](https://github.com/firebase/firebase-js-sdk/pull/5928) - Upgrade `node-fetch` dependency due to a security issue.
+
 ## 3.4.3
 
 ### Patch Changes

package/dist/firestore/src/api/database.d.ts

@@ -209,20 +209,25 @@ export declare function terminate(firestore: Firestore): Promise<void>;
 /**
  * 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>`.
  */
 export declare function loadBundle(firestore: Firestore, bundleData: ReadableStream<Uint8Array> | ArrayBuffer | string): LoadBundleTask;
 /**
- * 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`.
  */
 export declare function namedQuery(firestore: Firestore, name: string): Promise<Query | null>;

package/dist/firestore/src/api/index_configuration.d.ts

@@ -0,0 +1,117 @@
+/**
+ * @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.
+ */
+import { Firestore } from './database';
+export { connectFirestoreEmulator, EmulatorMockTokenOptions } from '../lite-api/database';
+/**
+ * A single field element in an index configuration.
+ *
+ * @internal
+ */
+export interface IndexField {
+    /** The field path to index. */
+    readonly fieldPath: string;
+    /**
+     * What type of array index to create. Set to `CONTAINS` for `array-contains`
+     * and `array-contains-any` indexes.
+     *
+     * Only one of `arrayConfig` or `order` should be set;
+     */
+    readonly arrayConfig?: 'CONTAINS';
+    /**
+     * What type of array index to create. Set to `ASCENDING` or 'DESCENDING` for
+     * `==`, `!=`, `<=`, `<=`, `in` and `not-in` filters.
+     *
+     * Only one of `arrayConfig` or `order` should be set.
+     */
+    readonly order?: 'ASCENDING' | 'DESCENDING';
+    [key: string]: unknown;
+}
+/**
+ * The SDK definition of a Firestore index.
+ *
+ * @internal
+ */
+export interface Index {
+    /** The ID of the collection to index. */
+    readonly collectionGroup: string;
+    /** A list of fields to index. */
+    readonly fields?: IndexField[];
+    [key: string]: unknown;
+}
+/**
+ * A list of Firestore indexes to speed up local query execution.
+ *
+ * See {@link https://firebase.google.com/docs/reference/firestore/indexes/#json_format | JSON Format}
+ * for a description of the format of the index definition.
+ *
+ * @internal
+ */
+export interface IndexConfiguration {
+    /** A list of all Firestore indexes. */
+    readonly indexes?: Index[];
+    [key: string]: unknown;
+}
+/**
+ * Configures indexing for local query execution. Any previous index
+ * configuration is overridden. The `Promise` resolves once the index
+ * configuration has been persisted.
+ *
+ * The index entries themselves are created asynchronously. You can continue to
+ * use queries that require indexing even if the indices are not yet available.
+ * Query execution will automatically start using the index once the index
+ * entries have been written.
+ *
+ * Indexes are only supported with IndexedDb persistence. Invoke either
+ * `enableIndexedDbPersistence()` or `enableMultiTabIndexedDbPersistence()`
+ * before setting an index configuration. If IndexedDb is not enabled, any
+ * index configuration is ignored.
+ *
+ * @internal
+ * @param firestore - The {@link Firestore} instance to configure indexes for.
+ * @param configuration -The index definition.
+ * @throws FirestoreError if the JSON format is invalid.
+ * @returns A `Promise` that resolves once all indices are successfully
+ * configured.
+ */
+export declare function setIndexConfiguration(firestore: Firestore, configuration: IndexConfiguration): Promise<void>;
+/**
+ * Configures indexing for local query execution. Any previous index
+ * configuration is overridden. The `Promise` resolves once the index
+ * configuration has been persisted.
+ *
+ * The index entries themselves are created asynchronously. You can continue to
+ * use queries that require indexing even if the indices are not yet available.
+ * Query execution will automatically start using the index once the index
+ * entries have been written.
+ *
+ * Indexes are only supported with IndexedDb persistence. Invoke either
+ * `enableIndexedDbPersistence()` or `enableMultiTabIndexedDbPersistence()`
+ * before setting an index configuration. If IndexedDb is not enabled, any
+ * index configuration is ignored.
+ *
+ * The method accepts the JSON format exported by the Firebase CLI (`firebase
+ * firestore:indexes`). If the JSON format is invalid, this method throws an
+ * error.
+ *
+ * @internal
+ * @param firestore - The {@link Firestore} instance to configure indexes for.
+ * @param json -The JSON format exported by the Firebase CLI.
+ * @throws FirestoreError if the JSON format is invalid.
+ * @returns A `Promise` that resolves once all indices are successfully
+ * configured.
+ */
+export declare function setIndexConfiguration(firestore: Firestore, json: string): Promise<void>;

package/dist/firestore/src/api/snapshot.d.ts

@@ -198,8 +198,7 @@ export declare class DocumentSnapshot<T = DocumentData> extends LiteDocumentSnap
     /** @hideconstructor protected */
     constructor(_firestore: Firestore, userDataWriter: AbstractUserDataWriter, key: DocumentKey, document: Document | null, metadata: SnapshotMetadata, converter: UntypedFirestoreDataConverter<T> | null);
     /**
-     * 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(): this is QueryDocumentSnapshot<T>;
     /**

package/dist/firestore/src/api.d.ts

@@ -20,7 +20,7 @@ export { LoadBundleTask, LoadBundleTaskProgress, TaskState } from './api/bundle'
 export { FirestoreSettings, PersistenceSettings } from './api/settings';
 export { DocumentChange, DocumentSnapshot, QueryDocumentSnapshot, QuerySnapshot, snapshotEqual, SnapshotOptions, FirestoreDataConverter, DocumentChangeType, SnapshotMetadata } from './api/snapshot';
 export { DocumentReference, CollectionReference, Query, doc, collection, collectionGroup, SetOptions, DocumentData, UpdateData, WithFieldValue, PartialWithFieldValue, refEqual, queryEqual } from './api/reference';
-export { endAt, endBefore, startAt, startAfter, limit, limitToLast, where, orderBy, query, QueryConstraint, QueryConstraintType, OrderByDirection, WhereFilterOp } from './api/query';
+export { endAt, endBefore, startAt, startAfter, limit, limitToLast, where, orderBy, query, QueryConstraint, QueryConstraintType, OrderByDirection, WhereFilterOp } from './api/filter';
 export { Unsubscribe, SnapshotListenOptions } from './api/reference_impl';
 export { runTransaction, Transaction } from './api/transaction';
 export { getDoc, getDocFromCache, getDocFromServer, getDocs, getDocsFromCache, getDocsFromServer, onSnapshot, onSnapshotsInSync, setDoc, updateDoc, deleteDoc, addDoc, executeWrite } from './api/reference_impl';
@@ -49,3 +49,4 @@ export type { ByteString as _ByteString } from './util/byte_string';
 export { logWarn as _logWarn } from './util/log';
 export { EmptyAuthCredentialsProvider as _EmptyAuthCredentialsProvider } from './api/credentials';
 export { EmptyAppCheckTokenProvider as _EmptyAppCheckTokenProvider } from './api/credentials';
+export { setIndexConfiguration as _setIndexConfiguration } from './api/index_configuration';

package/dist/firestore/src/core/database_info.d.ts

@@ -50,6 +50,7 @@ export declare class DatabaseId {
     readonly projectId: string;
     readonly database: string;
     constructor(projectId: string, database?: string);
+    static empty(): DatabaseId;
     get isDefaultDatabase(): boolean;
     isEqual(other: {}): boolean;
 }

package/dist/firestore/src/core/firestore_client.d.ts

@@ -53,6 +53,7 @@ export declare class FirestoreClient {
     private user;
     private readonly clientId;
     private authCredentialListener;
+    private appCheckCredentialListener;
     offlineComponents?: OfflineComponentProvider;
     onlineComponents?: OnlineComponentProvider;
     constructor(authCredentials: CredentialsProvider<User>, appCheckCredentials: CredentialsProvider<string>, 
@@ -67,6 +68,7 @@ export declare class FirestoreClient {
     asyncQueue: AsyncQueue, databaseInfo: DatabaseInfo);
     getConfiguration(): Promise<ComponentConfiguration>;
     setCredentialChangeListener(listener: (user: User) => Promise<void>): void;
+    setAppCheckTokenChangeListener(listener: (appCheckToken: string, user: User) => Promise<void>): void;
     /**
      * Checks that the client has not been terminated. Ensures that other methods on
      * this class cannot be called after the client is terminated.

package/dist/firestore/src/core/target.d.ts

@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 import { Document } from '../model/document';
+import { FieldIndex } from '../model/field_index';
 import { FieldPath, ResourcePath } from '../model/path';
 import { Value as ProtoValue } from '../protos/firestore_proto_api';
 /**
@@ -56,7 +57,31 @@ export declare function newTarget(path: ResourcePath, collectionGroup?: string |
 export declare function canonifyTarget(target: Target): string;
 export declare function stringifyTarget(target: Target): string;
 export declare function targetEquals(left: Target, right: Target): boolean;
-export declare function isDocumentTarget(target: Target): boolean;
+export declare function targetIsDocumentTarget(target: Target): boolean;
+/** Returns the field filters that target the given field path. */
+export declare function targetGetFieldFiltersForPath(target: Target, path: FieldPath): FieldFilter[];
+/**
+ * Returns the values that are used in ARRAY_CONTAINS or ARRAY_CONTAINS_ANY
+ * filters. Returns `null` if there are no such filters.
+ */
+export declare function targetGetArrayValues(target: Target, fieldIndex: FieldIndex): ProtoValue[] | null;
+/**
+ * Returns the list of values that are used in != or NOT_IN filters. Returns
+ * `null` if there are no such filters.
+ */
+export declare function targetGetNotInValues(target: Target, fieldIndex: FieldIndex): ProtoValue[] | null;
+/**
+ * Returns a lower bound of field values that can be used as a starting point to
+ * scan the index defined by `fieldIndex`. Returns `null` if no lower bound
+ * exists.
+ */
+export declare function targetGetLowerBound(target: Target, fieldIndex: FieldIndex): Bound | null;
+/**
+ * Returns an upper bound of field values that can be used as an ending point
+ * when scanning the index defined by `fieldIndex`. Returns `null` if no
+ * upper bound exists.
+ */
+export declare function targetGetUpperBound(target: Target, fieldIndex: FieldIndex): Bound | null;
 export declare abstract class Filter {
     abstract matches(doc: Document): boolean;
 }
@@ -151,10 +176,9 @@ export declare class ArrayContainsAnyFilter extends FieldFilter {
  */
 export declare class Bound {
     readonly position: ProtoValue[];
-    readonly before: boolean;
-    constructor(position: ProtoValue[], before: boolean);
+    readonly inclusive: boolean;
+    constructor(position: ProtoValue[], inclusive: boolean);
 }
-export declare function canonifyBound(bound: Bound): string;
 /**
  * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
  */
@@ -166,9 +190,14 @@ export declare class OrderBy {
 export declare function canonifyOrderBy(orderBy: OrderBy): string;
 export declare function stringifyOrderBy(orderBy: OrderBy): string;
 export declare function orderByEquals(left: OrderBy, right: OrderBy): boolean;
+/**
+ * Returns true if a document sorts after a bound using the provided sort
+ * order.
+ */
+export declare function boundSortsAfterDocument(bound: Bound, orderBy: OrderBy[], doc: Document): boolean;
 /**
  * Returns true if a document sorts before a bound using the provided sort
  * order.
  */
-export declare function sortsBeforeDocument(bound: Bound, orderBy: OrderBy[], doc: Document): boolean;
+export declare function boundSortsBeforeDocument(bound: Bound, orderBy: OrderBy[], doc: Document): boolean;
 export declare function boundEquals(left: Bound | null, right: Bound | null): boolean;

package/dist/firestore/src/lite-api/query.d.ts

@@ -196,8 +196,8 @@ export declare function newQueryOrderBy(query: InternalQuery, fieldPath: Interna
  * of the query or if any of the fields in the order by are an uncommitted
  * server timestamp.
  */
-export declare function newQueryBoundFromDocument(query: InternalQuery, databaseId: DatabaseId, methodName: string, doc: Document | null, before: boolean): Bound;
+export declare function newQueryBoundFromDocument(query: InternalQuery, databaseId: DatabaseId, methodName: string, doc: Document | null, inclusive: boolean): Bound;
 /**
  * Converts a list of field values to a `Bound` for the given query.
  */
-export declare function newQueryBoundFromFields(query: InternalQuery, databaseId: DatabaseId, dataReader: UserDataReader, methodName: string, values: unknown[], before: boolean): Bound;
+export declare function newQueryBoundFromFields(query: InternalQuery, databaseId: DatabaseId, dataReader: UserDataReader, methodName: string, values: unknown[], inclusive: boolean): Bound;

package/dist/firestore/src/local/index_manager.d.ts

@@ -14,6 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Target } from '../core/target';
+import { DocumentKeySet, DocumentMap } from '../model/collections';
+import { FieldIndex, IndexOffset } from '../model/field_index';
 import { ResourcePath } from '../model/path';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
@@ -40,4 +43,53 @@ export interface IndexManager {
      * path for a root-level collection).
      */
     getCollectionParents(transaction: PersistenceTransaction, collectionId: string): PersistencePromise<ResourcePath[]>;
+    /**
+     * Adds a field path index.
+     *
+     * Values for this index are persisted via the index backfill, which runs
+     * asynchronously in the background. Once the first values are written,
+     * an index can be used to serve partial results for any matching queries.
+     * Any unindexed portion of the database will continue to be served via
+     * collection scons.
+     */
+    addFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
+    /** Removes the given field index and deletes all index values. */
+    deleteFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
+    /**
+     * Returns a list of field indexes that correspond to the specified collection
+     * group.
+     *
+     * @param collectionGroup The collection group to get matching field indexes
+     * for.
+     * @return A collection of field indexes for the specified collection group.
+     */
+    getFieldIndexes(transaction: PersistenceTransaction, collectionGroup: string): PersistencePromise<FieldIndex[]>;
+    /** Returns all configured field indexes. */
+    getFieldIndexes(transaction: PersistenceTransaction): PersistencePromise<FieldIndex[]>;
+    /**
+     * Returns an index that can be used to serve the provided target. Returns
+     * `null` if no index is configured.
+     */
+    getFieldIndex(transaction: PersistenceTransaction, target: Target): PersistencePromise<FieldIndex | null>;
+    /**
+     * Returns the documents that match the given target based on the provided
+     * index.
+     */
+    getDocumentsMatchingTarget(transaction: PersistenceTransaction, fieldIndex: FieldIndex, target: Target): PersistencePromise<DocumentKeySet>;
+    /**
+     * Returns the next collection group to update. Returns `null` if no group
+     * exists.
+     */
+    getNextCollectionGroupToUpdate(transaction: PersistenceTransaction): PersistencePromise<string | null>;
+    /**
+     * Sets the collection group's latest read time.
+     *
+     * This method updates the index offset for all field indices for the
+     * collection group and increments their sequence number. Subsequent calls to
+     * `getNextCollectionGroupToUpdate()` will return a different collection group
+     * (unless only one collection group is configured).
+     */
+    updateCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset): PersistencePromise<void>;
+    /** Updates the index entries for the provided documents. */
+    updateIndexEntries(transaction: PersistenceTransaction, documents: DocumentMap): PersistencePromise<void>;
 }

package/dist/firestore/src/local/indexeddb_index_manager.d.ts

@@ -14,6 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Target } from '../core/target';
+import { DocumentKeySet, DocumentMap } from '../model/collections';
+import { FieldIndex, IndexOffset } from '../model/field_index';
 import { ResourcePath } from '../model/path';
 import { IndexManager } from './index_manager';
 import { PersistencePromise } from './persistence_promise';
@@ -39,4 +42,12 @@ export declare class IndexedDbIndexManager implements IndexManager {
      */
     addToCollectionParentIndex(transaction: PersistenceTransaction, collectionPath: ResourcePath): PersistencePromise<void>;
     getCollectionParents(transaction: PersistenceTransaction, collectionId: string): PersistencePromise<ResourcePath[]>;
+    addFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
+    deleteFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
+    getDocumentsMatchingTarget(transaction: PersistenceTransaction, fieldIndex: FieldIndex, target: Target): PersistencePromise<DocumentKeySet>;
+    getFieldIndex(transaction: PersistenceTransaction, target: Target): PersistencePromise<FieldIndex | null>;
+    getFieldIndexes(transaction: PersistenceTransaction, collectionGroup?: string): PersistencePromise<FieldIndex[]>;
+    getNextCollectionGroupToUpdate(transaction: PersistenceTransaction): PersistencePromise<string | null>;
+    updateCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset): PersistencePromise<void>;
+    updateIndexEntries(transaction: PersistenceTransaction, documents: DocumentMap): PersistencePromise<void>;
 }

package/dist/firestore/src/local/indexeddb_schema.d.ts

@@ -15,10 +15,12 @@
  * limitations under the License.
  */
 import { BatchId, TargetId } from '../core/types';
+import { IndexKind } from '../model/field_index';
 import { ResourcePath } from '../model/path';
 import { BundledQuery } from '../protos/firestore_bundle_proto';
 import { Document as ProtoDocument, DocumentsTarget as ProtoDocumentsTarget, QueryTarget as ProtoQueryTarget, Write as ProtoWrite } from '../protos/firestore_proto_api';
 import { EncodedResourcePath } from './encoded_resource_path';
+export declare const INDEXING_SCHEMA_VERSION = 12;
 /**
  * Schema Version for the Web client:
  * 1.  Initial version including Mutation Queue, Query Cache, and Remote
@@ -37,8 +39,9 @@ import { EncodedResourcePath } from './encoded_resource_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.
  */
-export declare const SCHEMA_VERSION = 11;
+export declare const SCHEMA_VERSION: number;
 /**
  * Wrapper class to store timestamps (seconds and nanos) in IndexedDb objects.
  */
@@ -763,9 +766,7 @@ export declare class DbClientMetadata {
 /** Object keys in the 'clientMetadata' store are clientId strings. */
 export declare type DbClientMetadataKey = string;
 export declare type DbBundlesKey = string;
-/**
- * A object representing a bundle loaded by the SDK.
- */
+/** An object representing a bundle loaded by the SDK. */
 export declare class DbBundle {
     /** The ID of the loaded bundle. */
     bundleId: string;
@@ -785,9 +786,7 @@ export declare class DbBundle {
     version: number);
 }
 export declare type DbNamedQueriesKey = string;
-/**
- * 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. */
 export declare class DbNamedQuery {
     /** The name of the query. */
     name: string;
@@ -806,12 +805,127 @@ export declare class DbNamedQuery {
     /** The query saved in the bundle. */
     bundledQuery: BundledQuery);
 }
+/** The key for each index consisting of just the index id. */
+export declare type DbIndexConfigurationKey = number;
+/** An object representing the global configuration for a field index. */
+export declare class DbIndexConfiguration {
+    /** The index id for this entry. */
+    indexId: number;
+    /** The collection group this index belongs to. */
+    collectionGroup: string;
+    /** The fields to index for this index. */
+    fields: [[name: string, kind: IndexKind]];
+    /** Name of the IndexedDb object store. */
+    static store: string;
+    static keyPath: string;
+    constructor(
+    /** The index id for this entry. */
+    indexId: number, 
+    /** The collection group this index belongs to. */
+    collectionGroup: string, 
+    /** The fields to index for this index. */
+    fields: [[name: string, kind: IndexKind]]);
+}
+/** The key for each index state consisting of the index id and its user id. */
+export declare type DbIndexStateKey = [number, string];
+/**
+ * An object describing how up-to-date the index backfill is for each user and
+ * index.
+ */
+export declare class DbIndexState {
+    /** The index id for this entry. */
+    indexId: number;
+    /** The user id for this entry. */
+    uid: string;
+    /**
+     * A number that indicates when the index was last updated (relative to
+     * other indexes).
+     */
+    sequenceNumber: number;
+    /**
+     * 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: DbTimestamp;
+    /**
+     * The last document that has been indexed for this field index. Empty if
+     * no documents have been indexed.
+     */
+    documentKey: EncodedResourcePath;
+    /**
+     * The largest mutation batch id that has been processed for this index. -1
+     * if no mutations have been indexed.
+     */
+    largestBatchId: number;
+    /** Name of the IndexedDb object store. */
+    static store: string;
+    static keyPath: string[];
+    constructor(
+    /** The index id for this entry. */
+    indexId: number, 
+    /** The user id for this entry. */
+    uid: string, 
+    /**
+     * A number that indicates when the index was last updated (relative to
+     * other indexes).
+     */
+    sequenceNumber: number, 
+    /**
+     * 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: DbTimestamp, 
+    /**
+     * The last document that has been indexed for this field index. Empty if
+     * no documents have been indexed.
+     */
+    documentKey: EncodedResourcePath, 
+    /**
+     * The largest mutation batch id that has been processed for this index. -1
+     * if no mutations have been indexed.
+     */
+    largestBatchId: number);
+}
+/**
+ * The key for each index entry consists of the index id and its user id,
+ * the encoded array and directional value for the indexed fields as well as
+ * the encoded document path for the indexed document.
+ */
+export declare type DbIndexEntryKey = [number, string, Uint8Array, Uint8Array, string];
+/** An object that stores the encoded entries for all documents and fields. */
+export declare class DbIndexEntries {
+    /** The index id for this entry. */
+    indexId: number;
+    /** The user id for this entry. */
+    uid: string;
+    /** The encoded array index value for this entry. */
+    arrayValue: Uint8Array;
+    /** The encoded directional value for equality and inequality filters. */
+    directionalValue: Uint8Array;
+    /** The document key this entry points to. */
+    documentKey: EncodedResourcePath;
+    /** Name of the IndexedDb object store. */
+    static store: string;
+    static keyPath: string[];
+    constructor(
+    /** The index id for this entry. */
+    indexId: number, 
+    /** The user id for this entry. */
+    uid: string, 
+    /** The encoded array index value for this entry. */
+    arrayValue: Uint8Array, 
+    /** The encoded directional value for equality and inequality filters. */
+    directionalValue: Uint8Array, 
+    /** The document key this entry points to. */
+    documentKey: EncodedResourcePath);
+}
 export declare const V1_STORES: string[];
 export declare const V3_STORES: string[];
 export declare const V4_STORES: string[];
 export declare const V6_STORES: string[];
 export declare const V8_STORES: string[];
 export declare const V11_STORES: string[];
+export declare const V12_STORES: string[];
 /**
  * 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

package/dist/firestore/src/local/local_serializer.d.ts

@@ -31,7 +31,7 @@ export declare class LocalSerializer {
 /** Decodes a remote document from storage locally to a Document. */
 export declare function fromDbRemoteDocument(localSerializer: LocalSerializer, remoteDoc: DbRemoteDocument): MutableDocument;
 /** Encodes a document for storage locally. */
-export declare function toDbRemoteDocument(localSerializer: LocalSerializer, document: MutableDocument, readTime: SnapshotVersion): DbRemoteDocument;
+export declare function toDbRemoteDocument(localSerializer: LocalSerializer, document: MutableDocument): DbRemoteDocument;
 export declare function toDbTimestampKey(snapshotVersion: SnapshotVersion): DbTimestampKey;
 export declare function fromDbTimestampKey(dbTimestampKey: DbTimestampKey): SnapshotVersion;
 /** Encodes a batch of mutations into a DbMutationBatch for local storage. */

package/dist/firestore/src/local/memory_index_manager.d.ts

@@ -14,6 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Target } from '../core/target';
+import { DocumentKeySet, DocumentMap } from '../model/collections';
+import { FieldIndex, IndexOffset } from '../model/field_index';
 import { ResourcePath } from '../model/path';
 import { IndexManager } from './index_manager';
 import { PersistencePromise } from './persistence_promise';
@@ -25,6 +28,14 @@ export declare class MemoryIndexManager implements IndexManager {
     private collectionParentIndex;
     addToCollectionParentIndex(transaction: PersistenceTransaction, collectionPath: ResourcePath): PersistencePromise<void>;
     getCollectionParents(transaction: PersistenceTransaction, collectionId: string): PersistencePromise<ResourcePath[]>;
+    addFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
+    deleteFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
+    getDocumentsMatchingTarget(transaction: PersistenceTransaction, fieldIndex: FieldIndex, target: Target): PersistencePromise<DocumentKeySet>;
+    getFieldIndex(transaction: PersistenceTransaction, target: Target): PersistencePromise<FieldIndex | null>;
+    getFieldIndexes(transaction: PersistenceTransaction, collectionGroup?: string): PersistencePromise<FieldIndex[]>;
+    getNextCollectionGroupToUpdate(transaction: PersistenceTransaction): PersistencePromise<string | null>;
+    updateCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset): PersistencePromise<void>;
+    updateIndexEntries(transaction: PersistenceTransaction, documents: DocumentMap): PersistencePromise<void>;
 }
 /**
  * Internal implementation of the collection-parent index exposed by MemoryIndexManager.

package/dist/firestore/src/local/remote_document_change_buffer.d.ts

@@ -21,13 +21,6 @@ import { DocumentKey } from '../model/document_key';
 import { ObjectMap } from '../util/obj_map';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
-/**
- * Represents a document change to be applied to remote document cache.
- */
-interface RemoteDocumentChange {
-    readonly document: MutableDocument;
-    readonly readTime: SnapshotVersion | null;
-}
 /**
  * An in-memory buffer of entries to be written to a RemoteDocumentCache.
  * It can be used to batch up a set of changes to be written to the cache, but
@@ -43,26 +36,25 @@ interface RemoteDocumentChange {
  * porting this class as part of that implementation work.
  */
 export declare abstract class RemoteDocumentChangeBuffer {
-    protected changes: ObjectMap<DocumentKey, RemoteDocumentChange>;
+    protected changes: ObjectMap<DocumentKey, MutableDocument>;
     private changesApplied;
     protected abstract getFromCache(transaction: PersistenceTransaction, documentKey: DocumentKey): PersistencePromise<MutableDocument>;
     protected abstract getAllFromCache(transaction: PersistenceTransaction, documentKeys: DocumentKeySet): PersistencePromise<MutableDocumentMap>;
     protected abstract applyChanges(transaction: PersistenceTransaction): PersistencePromise<void>;
-    protected getReadTime(key: DocumentKey): SnapshotVersion;
     /**
      * Buffers a `RemoteDocumentCache.addEntry()` call.
      *
      * You can only modify documents that have already been retrieved via
      * `getEntry()/getEntries()` (enforced via IndexedDbs `apply()`).
      */
-    addEntry(document: MutableDocument, readTime: SnapshotVersion): void;
+    addEntry(document: MutableDocument): void;
     /**
      * Buffers a `RemoteDocumentCache.removeEntry()` call.
      *
      * You can only remove documents that have already been retrieved via
      * `getEntry()/getEntries()` (enforced via IndexedDbs `apply()`).
      */
-    removeEntry(key: DocumentKey, readTime?: SnapshotVersion | null): void;
+    removeEntry(key: DocumentKey, readTime: SnapshotVersion): void;
     /**
      * Looks up an entry in the cache. The buffered changes will first be checked,
      * and if no buffered change applies, this will forward to
@@ -94,4 +86,3 @@ export declare abstract class RemoteDocumentChangeBuffer {
     /** Helper to assert this.changes is not null  */
     protected assertNotApplied(): void;
 }
-export {};