@firebase/firestore 3.4.4-canary.2dd99ae2d → 3.4.4-canary.307d019c7

package/dist/internal.d.ts

@@ -214,8 +214,8 @@ declare type BatchId = number;
  */
 declare class Bound {
     readonly position: Value[];
-    readonly before: boolean;
-    constructor(position: Value[], before: boolean);
+    readonly inclusive: boolean;
+    constructor(position: Value[], inclusive: boolean);
 }
 
 /**
@@ -938,8 +938,13 @@ export declare class _DocumentKey {
     static fromPath(path: string): _DocumentKey;
     static fromName(name: string): _DocumentKey;
     static empty(): _DocumentKey;
+    get collectionGroup(): string;
     /** Returns true if the document is in the specified collectionId. */
     hasCollectionId(collectionId: string): boolean;
+    /** Returns the collection group (i.e. the name of the parent collection) for this key. */
+    getCollectionGroup(): string;
+    /** Returns the fully qualified path to the parent collection. */
+    getCollectionPath(): _ResourcePath;
     isEqual(other: _DocumentKey | null): boolean;
     toString(): string;
     static comparator(k1: _DocumentKey, k2: _DocumentKey): number;
@@ -957,6 +962,56 @@ declare type DocumentKeySet = SortedSet<_DocumentKey>;
 
 declare type DocumentMap = SortedMap<_DocumentKey, Document_2>;
 
+/**
+ * Provides methods to read and write document overlays.
+ *
+ * An overlay is a saved mutation, that gives a local view of a document when
+ * applied to the remote version of the document.
+ *
+ * Each overlay stores the largest batch ID that is included in the overlay,
+ * which allows us to remove the overlay once all batches leading up to it have
+ * been acknowledged.
+ */
+declare interface DocumentOverlayCache {
+    /**
+     * Gets the saved overlay mutation for the given document key.
+     * Returns null if there is no overlay for that key.
+     */
+    getOverlay(transaction: PersistenceTransaction, key: _DocumentKey): PersistencePromise<Overlay | null>;
+    /**
+     * Saves the given document mutation map to persistence as overlays.
+     * All overlays will have their largest batch id set to `largestBatchId`.
+     */
+    saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: Map<_DocumentKey, Mutation>): PersistencePromise<void>;
+    /** Removes overlays for the given document keys and batch ID. */
+    removeOverlaysForBatchId(transaction: PersistenceTransaction, documentKeys: DocumentKeySet, batchId: number): PersistencePromise<void>;
+    /**
+     * Returns all saved overlays for the given collection.
+     *
+     * @param transaction - The persistence transaction to use for this operation.
+     * @param collection - The collection path to get the overlays for.
+     * @param sinceBatchId - The minimum batch ID to filter by (exclusive).
+     * Only overlays that contain a change past `sinceBatchId` are returned.
+     * @returns Mapping of each document key in the collection to its overlay.
+     */
+    getOverlaysForCollection(transaction: PersistenceTransaction, collection: _ResourcePath, sinceBatchId: number): PersistencePromise<Map<_DocumentKey, Overlay>>;
+    /**
+     * Returns `count` overlays with a batch ID higher than `sinceBatchId` for the
+     * provided collection group, processed by ascending batch ID. The method
+     * always returns all overlays for a batch even if the last batch contains
+     * more documents than the remaining limit.
+     *
+     * @param transaction - The persistence transaction used for this operation.
+     * @param collectionGroup - The collection group to get the overlays for.
+     * @param sinceBatchId - The minimum batch ID to filter by (exclusive).
+     * Only overlays that contain a change past `sinceBatchId` are returned.
+     * @param count - The number of overlays to return. Can be exceeded if the last
+     * batch contains more entries.
+     * @return Mapping of each document key in the collection group to its overlay.
+     */
+    getOverlaysForCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, sinceBatchId: number, count: number): PersistencePromise<Map<_DocumentKey, Overlay>>;
+}
+
 /**
  * A `DocumentReference` refers to a document location in a Firestore database
  * and can be used to write, read, or listen to the location. The document at
@@ -1074,8 +1129,7 @@ export declare class DocumentSnapshot<T = DocumentData> extends DocumentSnapshot
     /** @hideconstructor protected */
     constructor(_firestore: Firestore, userDataWriter: AbstractUserDataWriter, key: _DocumentKey, document: Document_2 | 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>;
     /**
@@ -1324,6 +1378,45 @@ export declare function executeWrite(firestore: Firestore, mutations: Mutation[]
 
 declare type FieldFilterOp = 'OPERATOR_UNSPECIFIED' | 'LESS_THAN' | 'LESS_THAN_OR_EQUAL' | 'GREATER_THAN' | 'GREATER_THAN_OR_EQUAL' | 'EQUAL' | 'NOT_EQUAL' | 'ARRAY_CONTAINS' | 'IN' | 'ARRAY_CONTAINS_ANY' | 'NOT_IN';
 
+/**
+ * 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.
+ */
+declare class FieldIndex {
+    /**
+     * The index ID. Returns -1 if the index ID is not available (e.g. the index
+     * has not yet been persisted).
+     */
+    readonly indexId: number;
+    /** The collection ID this index applies to. */
+    readonly collectionGroup: string;
+    /** The field segments for this index. */
+    readonly fields: IndexSegment[];
+    /** Shows how up-to-date the index is for the current user. */
+    readonly indexState: IndexState_2;
+    /** An ID for an index that has not yet been added to persistence.  */
+    static UNKNOWN_ID: number;
+    constructor(
+    /**
+     * The index ID. Returns -1 if the index ID is not available (e.g. the index
+     * has not yet been persisted).
+     */
+    indexId: number, 
+    /** The collection ID this index applies to. */
+    collectionGroup: string, 
+    /** The field segments for this index. */
+    fields: IndexSegment[], 
+    /** Shows how up-to-date the index is for the current user. */
+    indexState: IndexState_2);
+}
+
 /**
  * Provides a set of fields that can be used to partially patch a document.
  * FieldMask is used in conjunction with ObjectValue.
@@ -2363,6 +2456,20 @@ declare interface IndexField {
 
 declare type IndexFieldMode = 'MODE_UNSPECIFIED' | 'ASCENDING' | 'DESCENDING';
 
+/** The type of the index, e.g. for which type of query it can be used. */
+declare const enum IndexKind {
+    /**
+     * Ordered index. Can be used for <, <=, ==, >=, >, !=, IN and NOT IN queries.
+     */
+    ASCENDING = 0,
+    /**
+     * Ordered index. Can be used for <, <=, ==, >=, >, !=, IN and NOT IN queries.
+     */
+    DESCENDING = 1,
+    /** Contains index. Can be used for ArrayContains and ArrayContainsAny. */
+    CONTAINS = 2
+}
+
 /**
  * Represents a set of indexes that are used to execute queries efficiently.
  *
@@ -2386,10 +2493,125 @@ declare 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>;
+}
+
+/**
+ * Stores the latest read time, document and batch ID that were processed for an
+ * index.
+ */
+declare class IndexOffset {
+    /**
+     * The latest read time version that has been indexed by Firestore for this
+     * field index.
+     */
+    readonly readTime: SnapshotVersion;
+    /**
+     * The key of the last document that was indexed for this query. Use
+     * `DocumentKey.empty()` if no document has been indexed.
+     */
+    readonly documentKey: _DocumentKey;
+    readonly largestBatchId: number;
+    constructor(
+    /**
+     * The latest read time version that has been indexed by Firestore for this
+     * field index.
+     */
+    readTime: SnapshotVersion, 
+    /**
+     * The key of the last document that was indexed for this query. Use
+     * `DocumentKey.empty()` if no document has been indexed.
+     */
+    documentKey: _DocumentKey, largestBatchId: number);
+    /** The state of an index that has not yet been backfilled. */
+    static min(): IndexOffset;
+}
+
+/** An index component consisting of field path and index type.  */
+declare class IndexSegment {
+    /** The field path of the component. */
+    readonly fieldPath: _FieldPath;
+    /** The fields sorting order. */
+    readonly kind: IndexKind;
+    constructor(
+    /** The field path of the component. */
+    fieldPath: _FieldPath, 
+    /** The fields sorting order. */
+    kind: IndexKind);
 }
 
 declare type IndexState = 'STATE_UNSPECIFIED' | 'CREATING' | 'READY' | 'ERROR';
 
+/**
+ * Stores the "high water mark" that indicates how updated the Index is for the
+ * current user.
+ */
+declare class IndexState_2 {
+    /**
+     * Indicates when the index was last updated (relative to other indexes).
+     */
+    readonly sequenceNumber: number;
+    /** The the latest indexed read time, document and batch id. */
+    readonly offset: IndexOffset;
+    constructor(
+    /**
+     * Indicates when the index was last updated (relative to other indexes).
+     */
+    sequenceNumber: number, 
+    /** The the latest indexed read time, document and batch id. */
+    offset: IndexOffset);
+    /** The state of an index that has not yet been backfilled. */
+    static empty(): IndexState_2;
+}
+
 /**
  * Initializes a new instance of {@link Firestore} with the provided settings.
  * Can only be called before any other function, including
@@ -3406,6 +3628,21 @@ export declare type OrderByDirection = 'desc' | 'asc';
 
 declare type OrderDirection = 'DIRECTION_UNSPECIFIED' | 'ASCENDING' | 'DESCENDING';
 
+/**
+ * Representation of an overlay computed by Firestore.
+ *
+ * Holds information about a mutation and the largest batch id in Firestore when
+ * the mutation was created.
+ */
+declare class Overlay {
+    readonly largestBatchId: number;
+    readonly mutation: Mutation;
+    constructor(largestBatchId: number, mutation: Mutation);
+    getKey(): _DocumentKey;
+    isEqual(other: Overlay | null): boolean;
+    toString(): string;
+}
+
 declare interface ParseContext {
     readonly databaseId: _DatabaseId;
     readonly ignoreUndefinedProperties: boolean;
@@ -3509,7 +3746,7 @@ declare interface Persistence {
      * extent possible (e.g. in the case of uid switching from
      * sally=&gt;jack=&gt;sally, sally's mutation queue will be preserved).
      */
-    getMutationQueue(user: User): MutationQueue;
+    getMutationQueue(user: User, indexManager: IndexManager): MutationQueue;
     /**
      * Returns a TargetCache representing the persisted cache of targets.
      *
@@ -3542,7 +3779,12 @@ declare interface Persistence {
      * this is called. In particular, the memory-backed implementation does this
      * to emulate the persisted implementation to the extent possible.
      */
-    getIndexManager(): IndexManager;
+    getIndexManager(user: User): IndexManager;
+    /**
+     * Returns a DocumentOverlayCache representing the documents that are mutated
+     * locally.
+     */
+    getDocumentOverlayCache(user: User): DocumentOverlayCache;
     /**
      * Performs an operation inside a persistence transaction. Any reads or writes
      * against persistence must be performed within a transaction. Writes will be
@@ -3953,6 +4195,8 @@ declare type Rejector = (error: Error) => void;
  * documents that are known to not exist.
  */
 declare interface RemoteDocumentCache {
+    /** Sets the index manager to use for managing the collectionGroup index. */
+    setIndexManager(indexManager: IndexManager): void;
     /**
      * Looks up an entry in the cache.
      *
@@ -3970,19 +4214,14 @@ declare interface RemoteDocumentCache {
      */
     getEntries(transaction: PersistenceTransaction, documentKeys: DocumentKeySet): PersistencePromise<MutableDocumentMap>;
     /**
-     * Executes a query against the cached Document entries.
-     *
-     * Implementations may return extra documents if convenient. The results
-     * should be re-filtered by the consumer before presenting them to the user.
-     *
-     * Cached NoDocument entries have no bearing on query results.
+     * Returns the documents from the provided collection.
      *
-     * @param query - The query to match documents against.
+     * @param collection - The collection to read.
      * @param sinceReadTime - If not set to SnapshotVersion.min(), return only
      *     documents that have been read since this snapshot version (exclusive).
      * @returns The set of matching documents.
      */
-    getDocumentsMatchingQuery(transaction: PersistenceTransaction, query: Query_2, sinceReadTime: SnapshotVersion): PersistencePromise<MutableDocumentMap>;
+    getAll(transaction: PersistenceTransaction, collection: _ResourcePath, sinceReadTime: SnapshotVersion): PersistencePromise<MutableDocumentMap>;
     /**
      * Provides access to add or update the contents of the cache. The buffer
      * handles proper size accounting for the change.

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

@@ -176,6 +176,7 @@ export declare class FirebaseAppCheckTokenProvider implements CredentialsProvide
     private tokenListener;
     private forceRefresh;
     private appCheck;
+    private latestAppCheckToken;
     constructor(appCheckProvider: Provider<AppCheckInternalComponentName>);
     start(asyncQueue: AsyncQueue, changeListener: CredentialChangeListener<string>): void;
     getToken(): Promise<Token | null>;

package/dist/lite/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/lite/firestore/src/core/target.d.ts

@@ -176,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.
  */
@@ -191,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/lite/firestore/src/index/index_byte_encoder.d.ts

@@ -1,3 +1,20 @@
+/**
+ * @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 { IndexKind } from '../model/field_index';
 import { DirectionalIndexByteEncoder } from './directional_index_byte_encoder';
 /**
  * Implements `DirectionalIndexByteEncoder` using `OrderedCodeWriter` for the
@@ -8,7 +25,7 @@ export declare class IndexByteEncoder {
     private ascending;
     private descending;
     seed(encodedBytes: Uint8Array): void;
-    forKind(kind: 'asc' | 'desc'): DirectionalIndexByteEncoder;
+    forKind(kind: IndexKind): DirectionalIndexByteEncoder;
     encodedBytes(): Uint8Array;
     reset(): void;
 }

package/dist/lite/firestore/src/index/index_entry.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { DocumentKey } from '../model/document_key';
+/** Represents an index entry saved by the SDK in persisted storage. */
+export declare class IndexEntry {
+    readonly indexId: number;
+    readonly documentKey: DocumentKey;
+    readonly arrayValue: Uint8Array;
+    readonly directionalValue: Uint8Array;
+    constructor(indexId: number, documentKey: DocumentKey, arrayValue: Uint8Array, directionalValue: Uint8Array);
+}
+export declare function indexEntryComparator(left: IndexEntry, right: IndexEntry): number;

package/dist/lite/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/lite/firestore/src/local/document_overlay_cache.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { DocumentKeySet } from '../model/collections';
+import { DocumentKey } from '../model/document_key';
+import { Mutation } from '../model/mutation';
+import { Overlay } from '../model/overlay';
+import { ResourcePath } from '../model/path';
+import { PersistencePromise } from './persistence_promise';
+import { PersistenceTransaction } from './persistence_transaction';
+/**
+ * Provides methods to read and write document overlays.
+ *
+ * An overlay is a saved mutation, that gives a local view of a document when
+ * applied to the remote version of the document.
+ *
+ * Each overlay stores the largest batch ID that is included in the overlay,
+ * which allows us to remove the overlay once all batches leading up to it have
+ * been acknowledged.
+ */
+export interface DocumentOverlayCache {
+    /**
+     * Gets the saved overlay mutation for the given document key.
+     * Returns null if there is no overlay for that key.
+     */
+    getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
+    /**
+     * Saves the given document mutation map to persistence as overlays.
+     * All overlays will have their largest batch id set to `largestBatchId`.
+     */
+    saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: Map<DocumentKey, Mutation>): PersistencePromise<void>;
+    /** Removes overlays for the given document keys and batch ID. */
+    removeOverlaysForBatchId(transaction: PersistenceTransaction, documentKeys: DocumentKeySet, batchId: number): PersistencePromise<void>;
+    /**
+     * Returns all saved overlays for the given collection.
+     *
+     * @param transaction - The persistence transaction to use for this operation.
+     * @param collection - The collection path to get the overlays for.
+     * @param sinceBatchId - The minimum batch ID to filter by (exclusive).
+     * Only overlays that contain a change past `sinceBatchId` are returned.
+     * @returns Mapping of each document key in the collection to its overlay.
+     */
+    getOverlaysForCollection(transaction: PersistenceTransaction, collection: ResourcePath, sinceBatchId: number): PersistencePromise<Map<DocumentKey, Overlay>>;
+    /**
+     * Returns `count` overlays with a batch ID higher than `sinceBatchId` for the
+     * provided collection group, processed by ascending batch ID. The method
+     * always returns all overlays for a batch even if the last batch contains
+     * more documents than the remaining limit.
+     *
+     * @param transaction - The persistence transaction used for this operation.
+     * @param collectionGroup - The collection group to get the overlays for.
+     * @param sinceBatchId - The minimum batch ID to filter by (exclusive).
+     * Only overlays that contain a change past `sinceBatchId` are returned.
+     * @param count - The number of overlays to return. Can be exceeded if the last
+     * batch contains more entries.
+     * @return Mapping of each document key in the collection group to its overlay.
+     */
+    getOverlaysForCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, sinceBatchId: number, count: number): PersistencePromise<Map<DocumentKey, Overlay>>;
+}

package/dist/lite/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/lite/firestore/src/local/indexeddb_document_overlay_cache.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { User } from '../auth/user';
+import { DocumentKeySet } from '../model/collections';
+import { DocumentKey } from '../model/document_key';
+import { Mutation } from '../model/mutation';
+import { Overlay } from '../model/overlay';
+import { ResourcePath } from '../model/path';
+import { DocumentOverlayCache } from './document_overlay_cache';
+import { LocalSerializer } from './local_serializer';
+import { PersistencePromise } from './persistence_promise';
+import { PersistenceTransaction } from './persistence_transaction';
+/**
+ * Implementation of DocumentOverlayCache using IndexedDb.
+ */
+export declare class IndexedDbDocumentOverlayCache implements DocumentOverlayCache {
+    private readonly serializer;
+    private readonly userId;
+    /**
+     * @param serializer - The document serializer.
+     * @param userId - The userId for which we are accessing overlays.
+     */
+    constructor(serializer: LocalSerializer, userId: string);
+    static forUser(serializer: LocalSerializer, user: User): IndexedDbDocumentOverlayCache;
+    getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
+    saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: Map<DocumentKey, Mutation>): PersistencePromise<void>;
+    removeOverlaysForBatchId(transaction: PersistenceTransaction, documentKeys: DocumentKeySet, batchId: number): PersistencePromise<void>;
+    getOverlaysForCollection(transaction: PersistenceTransaction, collection: ResourcePath, sinceBatchId: number): PersistencePromise<Map<DocumentKey, Overlay>>;
+    getOverlaysForCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, sinceBatchId: number, count: number): PersistencePromise<Map<DocumentKey, Overlay>>;
+    private saveOverlay;
+}