@firebase/firestore 3.4.5 → 3.4.6-canary.3198d58dc

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

@@ -38,4 +38,5 @@ export declare class SchemaConverter implements SimpleDbSchemaConverter {
     private ensureSequenceNumbers;
     private createCollectionParentIndex;
     private rewriteCanonicalIds;
+    private rewriteRemoteDocumentCache;
 }

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

@@ -0,0 +1,29 @@
+/**
+ * @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 { Document as ProtoDocument } from '../protos/firestore_proto_api';
+import { DbNoDocument, DbUnknownDocument } from './indexeddb_schema';
+import { DbTimestampKey } from './indexeddb_sentinels';
+export interface DbRemoteDocument {
+    unknownDocument?: DbUnknownDocument;
+    noDocument?: DbNoDocument;
+    document?: ProtoDocument;
+    hasCommittedMutations?: boolean;
+    readTime?: DbTimestampKey;
+    parentPath?: string[];
+}
+export declare type DbRemoteDocumentKey = string[];
+export declare const DbRemoteDocumentStore = "remoteDocuments";

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

@@ -0,0 +1,243 @@
+/**
+ * @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 { BatchId, TargetId } from '../core/types';
+import { ResourcePath } from '../model/path';
+import { EncodedResourcePath } from './encoded_resource_path';
+import { DbDocumentMutation } from './indexeddb_schema';
+/** A timestamp type that can be used in IndexedDb keys. */
+export declare type DbTimestampKey = [/* seconds */ number, /* nanos */ number];
+export declare type DbPrimaryClientKey = typeof DbPrimaryClientKey;
+/**
+ * Name of the IndexedDb object store.
+ *
+ * Note that the name 'owner' is chosen to ensure backwards compatibility with
+ * older clients that only supported single locked access to the persistence
+ * layer.
+ */
+export declare const DbPrimaryClientStore = "owner";
+/**
+ * The key string used for the single object that exists in the
+ * DbPrimaryClient store.
+ */
+export declare const DbPrimaryClientKey = "owner";
+/** Object keys in the 'mutationQueues' store are userId strings. */
+export declare type DbMutationQueueKey = string;
+/** Name of the IndexedDb object store.  */
+export declare const DbMutationQueueStore = "mutationQueues";
+/** Keys are automatically assigned via the userId property. */
+export declare const DbMutationQueueKeyPath = "userId";
+/** The 'mutations' store  is keyed by batch ID. */
+export declare type DbMutationBatchKey = BatchId;
+/** Name of the IndexedDb object store.  */
+export declare const DbMutationBatchStore = "mutations";
+/** Keys are automatically assigned via the userId, batchId properties. */
+export declare const DbMutationBatchKeyPath = "batchId";
+/** The index name for lookup of mutations by user. */
+export declare const DbMutationBatchUserMutationsIndex = "userMutationsIndex";
+/** The user mutations index is keyed by [userId, batchId] pairs. */
+export declare const DbMutationBatchUserMutationsKeyPath: string[];
+/**
+ * The key for a db document mutation, which is made up of a userID, path, and
+ * batchId. Note that the path must be serialized into a form that indexedDB can
+ * sort.
+ */
+export declare type DbDocumentMutationKey = [string, EncodedResourcePath, BatchId];
+/**
+ * Creates a [userId] key for use in the DbDocumentMutations index to iterate
+ * over all of a user's document mutations.
+ */
+export declare function newDbDocumentMutationPrefixForUser(userId: string): [string];
+/**
+ * Creates a [userId, encodedPath] key for use in the DbDocumentMutations
+ * index to iterate over all at document mutations for a given path or lower.
+ */
+export declare function newDbDocumentMutationPrefixForPath(userId: string, path: ResourcePath): [string, EncodedResourcePath];
+/**
+ * Creates a full index key of [userId, encodedPath, batchId] for inserting
+ * and deleting into the DbDocumentMutations index.
+ */
+export declare function newDbDocumentMutationKey(userId: string, path: ResourcePath, batchId: BatchId): DbDocumentMutationKey;
+/**
+ * Because we store all the useful information for this store in the key,
+ * there is no useful information to store as the value. The raw (unencoded)
+ * path cannot be stored because IndexedDb doesn't store prototype
+ * information.
+ */
+export declare const DbDocumentMutationPlaceholder: DbDocumentMutation;
+export declare const DbDocumentMutationStore = "documentMutations";
+export declare const DbRemoteDocumentStore = "remoteDocumentsV14";
+/**
+ * A key in the 'remoteDocumentsV14' object store is an array containing the
+ * collection path, the collection group, the read time and the document id.
+ */
+export declare type DbRemoteDocumentKey = [
+    /** path to collection */ string[],
+    /** collection group */ string,
+    /** read time */ DbTimestampKey,
+    /** document ID */ string
+];
+/**
+ * The primary key of the remote documents store, which allows for efficient
+ * access by collection path and read time.
+ */
+export declare const DbRemoteDocumentKeyPath: string[];
+/** An index that provides access to documents by key. */
+export declare const DbRemoteDocumentDocumentKeyIndex = "documentKeyIndex";
+export declare const DbRemoteDocumentDocumentKeyIndexPath: string[];
+/**
+ * An index that provides access to documents by collection group and read
+ * time.
+ *
+ * This index is used by the index backfiller.
+ */
+export declare const DbRemoteDocumentCollectionGroupIndex = "collectionGroupIndex";
+export declare const DbRemoteDocumentCollectionGroupIndexPath: string[];
+export declare const DbRemoteDocumentGlobalStore = "remoteDocumentGlobal";
+export declare const DbRemoteDocumentGlobalKey = "remoteDocumentGlobalKey";
+export declare type DbRemoteDocumentGlobalKey = typeof DbRemoteDocumentGlobalKey;
+/**
+ * A key in the 'targets' object store is a targetId of the query.
+ */
+export declare type DbTargetKey = TargetId;
+export declare const DbTargetStore = "targets";
+/** Keys are automatically assigned via the targetId property. */
+export declare const DbTargetKeyPath = "targetId";
+/** The name of the queryTargets index. */
+export declare const DbTargetQueryTargetsIndexName = "queryTargetsIndex";
+/**
+ * The index of all canonicalIds to the targets that they match. This is not
+ * a unique mapping because canonicalId does not promise a unique name for all
+ * possible queries, so we append the targetId to make the mapping unique.
+ */
+export declare const DbTargetQueryTargetsKeyPath: string[];
+/**
+ * The key for a DbTargetDocument, containing a targetId and an encoded resource
+ * path.
+ */
+export declare type DbTargetDocumentKey = [TargetId, EncodedResourcePath];
+/** Name of the IndexedDb object store.  */
+export declare const DbTargetDocumentStore = "targetDocuments";
+/** Keys are automatically assigned via the targetId, path properties. */
+export declare const DbTargetDocumentKeyPath: string[];
+/** The index name for the reverse index. */
+export declare const DbTargetDocumentDocumentTargetsIndex = "documentTargetsIndex";
+/** We also need to create the reverse index for these properties. */
+export declare const DbTargetDocumentDocumentTargetsKeyPath: string[];
+/**
+ * The type to represent the single allowed key for the DbTargetGlobal store.
+ */
+export declare type DbTargetGlobalKey = typeof DbTargetGlobalKey;
+/**
+ * The key string used for the single object that exists in the
+ * DbTargetGlobal store.
+ */
+export declare const DbTargetGlobalKey = "targetGlobalKey";
+export declare const DbTargetGlobalStore = "targetGlobal";
+/**
+ * The key for a DbCollectionParent entry, containing the collection ID
+ * and the parent path that contains it. Note that the parent path will be an
+ * empty path in the case of root-level collections.
+ */
+export declare type DbCollectionParentKey = [string, EncodedResourcePath];
+/** Name of the IndexedDb object store. */
+export declare const DbCollectionParentStore = "collectionParents";
+/** Keys are automatically assigned via the collectionId, parent properties. */
+export declare const DbCollectionParentKeyPath: string[];
+/** Name of the IndexedDb object store. */
+export declare const DbClientMetadataStore = "clientMetadata";
+/** Keys are automatically assigned via the clientId properties. */
+export declare const DbClientMetadataKeyPath = "clientId";
+/** Object keys in the 'clientMetadata' store are clientId strings. */
+export declare type DbClientMetadataKey = string;
+export declare type DbBundlesKey = string;
+/** Name of the IndexedDb object store. */
+export declare const DbBundleStore = "bundles";
+export declare const DbBundleKeyPath = "bundleId";
+export declare type DbNamedQueriesKey = string;
+/** Name of the IndexedDb object store. */
+export declare const DbNamedQueryStore = "namedQueries";
+export declare const DbNamedQueryKeyPath = "name";
+/** The key for each index consisting of just the index id. */
+export declare type DbIndexConfigurationKey = number;
+/** Name of the IndexedDb object store. */
+export declare const DbIndexConfigurationStore = "indexConfiguration";
+export declare const DbIndexConfigurationKeyPath = "indexId";
+/**
+ * An index that provides access to the index configurations by collection
+ * group.
+ *
+ * PORTING NOTE: iOS and Android maintain this index in-memory, but this is
+ * not possible here as the Web client supports concurrent access to
+ * persistence via multi-tab.
+ */
+export declare const DbIndexConfigurationCollectionGroupIndex = "collectionGroupIndex";
+export declare const DbIndexConfigurationCollectionGroupIndexPath = "collectionGroup";
+/** The key for each index state consisting of the index id and its user id. */
+export declare type DbIndexStateKey = [number, string];
+/** Name of the IndexedDb object store. */
+export declare const DbIndexStateStore = "indexState";
+export declare const DbIndexStateKeyPath: string[];
+/**
+ * An index that provides access to documents in a collection sorted by last
+ * update time. Used by the backfiller.
+ *
+ * PORTING NOTE: iOS and Android maintain this index in-memory, but this is
+ * not possible here as the Web client supports concurrent access to
+ * persistence via multi-tab.
+ */
+export declare const DbIndexStateSequenceNumberIndex = "sequenceNumberIndex";
+export declare const DbIndexStateSequenceNumberIndexPath: string[];
+/**
+ * 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];
+/** Name of the IndexedDb object store. */
+export declare const DbIndexEntryStore = "indexEntries";
+export declare const DbIndexEntryKeyPath: string[];
+export declare const DbIndexEntryDocumentKeyIndex = "documentKeyIndex";
+export declare const DbIndexEntryDocumentKeyIndexPath: string[];
+export declare type DbDocumentOverlayKey = [
+    string,
+    string,
+    string
+];
+/** Name of the IndexedDb object store. */
+export declare const DbDocumentOverlayStore = "documentOverlays";
+export declare const DbDocumentOverlayKeyPath: string[];
+export declare const DbDocumentOverlayCollectionPathOverlayIndex = "collectionPathOverlayIndex";
+export declare const DbDocumentOverlayCollectionPathOverlayIndexPath: string[];
+export declare const DbDocumentOverlayCollectionGroupOverlayIndex = "collectionGroupOverlayIndex";
+export declare const DbDocumentOverlayCollectionGroupOverlayIndexPath: string[];
+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[];
+export declare const V13_STORES: string[];
+export declare const V14_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
+ * atomically.
+ */
+export declare const ALL_STORES: string[];
+/** Returns the object stores for the provided schema. */
+export declare function getObjectStores(schemaVersion: number): string[];

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

@@ -20,7 +20,8 @@ import { ListenSequenceNumber, TargetId } from '../core/types';
 import { DocumentKeySet } from '../model/collections';
 import { DocumentKey } from '../model/document_key';
 import { IndexedDbLruDelegate } from './indexeddb_lru_delegate';
-import { DbTargetDocument, DbTargetDocumentKey } from './indexeddb_schema';
+import { DbTargetDocument } from './indexeddb_schema';
+import { DbTargetDocumentKey } from './indexeddb_sentinels';
 import { LocalSerializer } from './local_serializer';
 import { ActiveTargets } from './lru_garbage_collector';
 import { PersistencePromise } from './persistence_promise';

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

@@ -15,10 +15,10 @@
  * limitations under the License.
  */
 import { Query } from '../core/query';
-import { SnapshotVersion } from '../core/snapshot_version';
 import { DocumentKeySet, DocumentMap, MutableDocumentMap } from '../model/collections';
 import { Document } from '../model/document';
 import { DocumentKey } from '../model/document_key';
+import { IndexOffset } from '../model/field_index';
 import { IndexManager } from './index_manager';
 import { MutationQueue } from './mutation_queue';
 import { PersistencePromise } from './persistence_promise';
@@ -62,10 +62,9 @@ export declare class LocalDocumentsView {
      *
      * @param transaction - The persistence transaction.
      * @param query - The query to match documents against.
-     * @param sinceReadTime - If not set to SnapshotVersion.min(), return only
-     *     documents that have been read since this snapshot version (exclusive).
+     * @param offset - Read time and key to start scanning by (exclusive).
      */
-    getDocumentsMatchingQuery(transaction: PersistenceTransaction, query: Query, sinceReadTime: SnapshotVersion): PersistencePromise<DocumentMap>;
+    getDocumentsMatchingQuery(transaction: PersistenceTransaction, query: Query, offset: IndexOffset): PersistencePromise<DocumentMap>;
     private getDocumentsMatchingDocumentQuery;
     private getDocumentsMatchingCollectionGroupQuery;
     private getDocumentsMatchingCollectionQuery;

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

@@ -25,7 +25,8 @@ import { MutationBatch } from '../model/mutation_batch';
 import { Overlay } from '../model/overlay';
 import { BundledQuery as ProtoBundledQuery, BundleMetadata as ProtoBundleMetadata, NamedQuery as ProtoNamedQuery } from '../protos/firestore_bundle_proto';
 import { JsonProtoSerializer } from '../remote/serializer';
-import { DbBundle, DbDocumentOverlay, DbDocumentOverlayKey, DbIndexConfiguration, DbIndexState, DbMutationBatch, DbNamedQuery, DbRemoteDocument, DbTarget, DbTimestampKey } from './indexeddb_schema';
+import { DbBundle, DbDocumentOverlay, DbIndexConfiguration, DbIndexState, DbMutationBatch, DbNamedQuery, DbRemoteDocument, DbTarget, DbTimestamp } from './indexeddb_schema';
+import { DbDocumentOverlayKey, DbTimestampKey } from './indexeddb_sentinels';
 import { TargetData } from './target_data';
 /** Serializer for values stored in the LocalStore. */
 export declare class LocalSerializer {
@@ -38,6 +39,7 @@ export declare function fromDbRemoteDocument(localSerializer: LocalSerializer, r
 export declare function toDbRemoteDocument(localSerializer: LocalSerializer, document: MutableDocument): DbRemoteDocument;
 export declare function toDbTimestampKey(snapshotVersion: SnapshotVersion): DbTimestampKey;
 export declare function fromDbTimestampKey(dbTimestampKey: DbTimestampKey): SnapshotVersion;
+export declare function toDbTimestamp(snapshotVersion: SnapshotVersion): DbTimestamp;
 /** Encodes a batch of mutations into a DbMutationBatch for local storage. */
 export declare function toDbMutationBatch(localSerializer: LocalSerializer, userId: string, batch: MutationBatch): DbMutationBatch;
 /** Decodes a DbMutationBatch into a MutationBatch */

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

@@ -165,13 +165,7 @@ export declare function localStoreGetCachedTarget(localStore: LocalStore, target
  * initialization. Further invocations will return document that have changed
  * since the prior call.
  */
-export declare function localStoreGetNewDocumentChanges(localStore: LocalStore): Promise<DocumentMap>;
-/**
- * Reads the newest document change from persistence and moves the internal
- * synchronization marker forward so that calls to `getNewDocumentChanges()`
- * only return changes that happened after client initialization.
- */
-export declare function localStoreSynchronizeLastDocumentChangeReadTime(localStore: LocalStore): Promise<void>;
+export declare function localStoreGetNewDocumentChanges(localStore: LocalStore, collectionGroup: string): Promise<DocumentMap>;
 /**
  * Applies the documents from a bundle to the "ground-state" (remote)
  * documents.

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

@@ -14,9 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { DocumentKeySet } from '../model/collections';
+import { DocumentKeySet, MutationMap, OverlayMap } 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';
@@ -29,9 +28,9 @@ export declare class MemoryDocumentOverlayCache implements DocumentOverlayCache
     private overlays;
     private overlayByBatchId;
     getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
-    saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: Map<DocumentKey, Mutation>): PersistencePromise<void>;
+    saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: MutationMap): 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>>;
+    getOverlaysForCollection(transaction: PersistenceTransaction, collection: ResourcePath, sinceBatchId: number): PersistencePromise<OverlayMap>;
+    getOverlaysForCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, sinceBatchId: number, count: number): PersistencePromise<OverlayMap>;
     private saveOverlay;
 }

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

@@ -30,7 +30,7 @@ export declare class MemoryIndexManager implements IndexManager {
     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>;
+    getDocumentsMatchingTarget(transaction: PersistenceTransaction, target: Target): PersistencePromise<DocumentKeySet | null>;
     getFieldIndex(transaction: PersistenceTransaction, target: Target): PersistencePromise<FieldIndex | null>;
     getFieldIndexes(transaction: PersistenceTransaction, collectionGroup?: string): PersistencePromise<FieldIndex[]>;
     getNextCollectionGroupToUpdate(transaction: PersistenceTransaction): PersistencePromise<string | null>;

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

@@ -14,10 +14,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { SnapshotVersion } from '../core/snapshot_version';
 import { DocumentKeySet, MutableDocumentMap } from '../model/collections';
 import { MutableDocument } from '../model/document';
 import { DocumentKey } from '../model/document_key';
+import { IndexOffset } from '../model/field_index';
 import { ResourcePath } from '../model/path';
 import { IndexManager } from './index_manager';
 import { PersistencePromise } from './persistence_promise';
@@ -53,11 +53,20 @@ export interface RemoteDocumentCache {
      * Returns the documents from the provided collection.
      *
      * @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).
+     * @param offset - The offset to start the scan at (exclusive).
      * @returns The set of matching documents.
      */
-    getAll(transaction: PersistenceTransaction, collection: ResourcePath, sinceReadTime: SnapshotVersion): PersistencePromise<MutableDocumentMap>;
+    getAllFromCollection(transaction: PersistenceTransaction, collection: ResourcePath, offset: IndexOffset): PersistencePromise<MutableDocumentMap>;
+    /**
+     * Looks up the next `limit` documents for a collection group based on the
+     * provided offset. The ordering is based on the document's read time and key.
+     *
+     * @param collectionGroup - The collection group to scan.
+     * @param offset - The offset to start the scan at (exclusive).
+     * @param limit - The maximum number of results to return.
+     * @returns The set of matching documents.
+     */
+    getAllFromCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset, limit: number): PersistencePromise<MutableDocumentMap>;
     /**
      * Provides access to add or update the contents of the cache. The buffer
      * handles proper size accounting for the change.

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

@@ -113,8 +113,10 @@ export interface SharedClientState {
     /**
      * Notifies other clients when remote documents have changed due to loading
      * a bundle.
+     *
+     * @param collectionGroups The collection groups affected by this bundle.
      */
-    notifyBundleLoaded(): void;
+    notifyBundleLoaded(collectionGroups: Set<string>): void;
 }
 /**
  * Holds the state of a mutation batch, including its user ID, batch ID and
@@ -237,7 +239,7 @@ export declare class WebStorageSharedClientState implements SharedClientState {
     updateQueryState(targetId: TargetId, state: QueryTargetState, error?: FirestoreError): void;
     handleUserChange(user: User, removedBatchIds: BatchId[], addedBatchIds: BatchId[]): void;
     setOnlineState(onlineState: OnlineState): void;
-    notifyBundleLoaded(): void;
+    notifyBundleLoaded(collectionGroups: Set<string>): void;
     shutdown(): void;
     private getItem;
     private setItem;
@@ -275,6 +277,7 @@ export declare class WebStorageSharedClientState implements SharedClientState {
      * could not be parsed.
      */
     private fromWebStorageOnlineState;
+    private fromWebStoreBundleLoadedState;
     private handleMutationBatchEvent;
     private handleQueryTargetEvent;
     private handleClientStateEvent;
@@ -305,5 +308,5 @@ export declare class MemorySharedClientState implements SharedClientState {
     setOnlineState(onlineState: OnlineState): void;
     shutdown(): void;
     writeSequenceNumber(sequenceNumber: ListenSequenceNumber): void;
-    notifyBundleLoaded(): void;
+    notifyBundleLoaded(collectionGroups: Set<string>): void;
 }

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

@@ -64,7 +64,7 @@ export interface QueryTargetStateSchema {
 export declare const ONLINE_STATE_KEY_PREFIX = "firestore_online_state";
 /** Assembles the key for the online state of the primary tab. */
 export declare function createWebStorageOnlineStateKey(persistenceKey: string): string;
-export declare const BUNDLE_LOADED_KEY_PREFIX = "firestore_bundle_loaded";
+export declare const BUNDLE_LOADED_KEY_PREFIX = "firestore_bundle_loaded_v2";
 export declare function createBundleLoadedKey(persistenceKey: string): string;
 /**
  * The JSON representation of the system's online state, as written by the

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

@@ -36,5 +36,5 @@ export interface SharedClientStateSyncer {
      * Retrieves newly changed documents from remote document cache and raises
      * snapshots if needed.
      */
-    synchronizeWithChangedDocuments(): Promise<void>;
+    synchronizeWithChangedDocuments(collectionGroup: string): Promise<void>;
 }

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

@@ -182,9 +182,20 @@ export declare class SimpleDbStore<KeyType extends IDBValidKey, ValueType extend
      * Returns the number of rows in the store.
      */
     count(): PersistencePromise<number>;
+    /** Loads all elements from the object store. */
     loadAll(): PersistencePromise<ValueType[]>;
+    /** Loads all elements for the index range from the object store. */
     loadAll(range: IDBKeyRange): PersistencePromise<ValueType[]>;
+    /**
+     * Loads all elements from the object store that fall into the provided in the
+     * index range for the given index.
+     */
     loadAll(index: string, range: IDBKeyRange): PersistencePromise<ValueType[]>;
+    /**
+     * Loads the first `count` elements from the provided index range. Loads all
+     * elements if no limit is provided.
+     */
+    loadFirst(range: IDBKeyRange, count: number | null): PersistencePromise<ValueType[]>;
     deleteAll(): PersistencePromise<void>;
     deleteAll(range: IDBKeyRange): PersistencePromise<void>;
     deleteAll(index: string, range: IDBKeyRange): PersistencePromise<void>;

package/dist/firestore/src/model/collections.d.ts

@@ -16,10 +16,13 @@
  */
 import { SnapshotVersion } from '../core/snapshot_version';
 import { TargetId } from '../core/types';
+import { ObjectMap } from '../util/obj_map';
 import { SortedMap } from '../util/sorted_map';
 import { SortedSet } from '../util/sorted_set';
 import { Document, MutableDocument } from './document';
 import { DocumentKey } from './document_key';
+import { Mutation } from './mutation';
+import { Overlay } from './overlay';
 /** Miscellaneous collection types / constants. */
 export declare type MutableDocumentMap = SortedMap<DocumentKey, MutableDocument>;
 export declare function mutableDocumentMap(): MutableDocumentMap;
@@ -29,6 +32,10 @@ export interface DocumentSizeEntries {
 }
 export declare type DocumentMap = SortedMap<DocumentKey, Document>;
 export declare function documentMap(): DocumentMap;
+export declare type OverlayMap = ObjectMap<DocumentKey, Overlay>;
+export declare function newOverlayMap(): OverlayMap;
+export declare type MutationMap = ObjectMap<DocumentKey, Mutation>;
+export declare function newMutationMap(): MutationMap;
 export declare type DocumentVersionMap = SortedMap<DocumentKey, SnapshotVersion>;
 export declare function documentVersionMap(): DocumentVersionMap;
 export declare type DocumentKeySet = SortedSet<DocumentKey>;

package/dist/firestore/src/model/field_index.d.ts

@@ -18,6 +18,11 @@ import { SnapshotVersion } from '../core/snapshot_version';
 import { Document } from './document';
 import { DocumentKey } from './document_key';
 import { FieldPath } from './path';
+/**
+ * The initial mutation batch id for each index. Gets updated during index
+ * backfill.
+ */
+export declare const INITIAL_LARGEST_BATCH_ID = -1;
 /**
  * The initial sequence number for each index. Gets updated during index
  * backfill.
@@ -70,6 +75,8 @@ export declare function fieldIndexGetDirectionalSegments(fieldIndex: FieldIndex)
  * index ID.
  */
 export declare function fieldIndexSemanticComparator(left: FieldIndex, right: FieldIndex): number;
+/** Returns a debug representation of the field index */
+export declare function fieldIndexToString(fieldIndex: FieldIndex): string;
 /** The type of the index, e.g. for which type of query it can be used. */
 export declare const enum IndexKind {
     /**
@@ -150,7 +157,9 @@ export declare class IndexOffset {
      * `DocumentKey.empty()` if no document has been indexed.
      */
     documentKey: DocumentKey, largestBatchId: number);
-    /** The state of an index that has not yet been backfilled. */
+    /** Returns an offset that sorts before all regular offsets. */
     static min(): IndexOffset;
+    /** Returns an offset that sorts after all regular offsets. */
+    static max(): IndexOffset;
 }
 export declare function indexOffsetComparator(left: IndexOffset, right: IndexOffset): number;

package/dist/firestore/src/model/type_order.d.ts

@@ -32,5 +32,6 @@ export declare const enum TypeOrder {
     RefValue = 7,
     GeoPointValue = 8,
     ArrayValue = 9,
-    ObjectValue = 10
+    ObjectValue = 10,
+    MaxValue = 9007199254740991
 }

package/dist/firestore/src/platform/node/base64.d.ts

@@ -14,6 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/** Converts a Base64 encoded string to a binary string. */
 export declare function decodeBase64(encoded: string): string;
 /** Converts a binary string to a Base64 encoded string. */
 export declare function encodeBase64(raw: string): string;

package/dist/firestore/src/util/obj_map.d.ts

@@ -30,6 +30,8 @@ export declare class ObjectMap<KeyType, ValueType> {
      * constant time lookups in practice.
      */
     private inner;
+    /** The number of entries stored in the map */
+    private innerSize;
     constructor(mapKeyFn: (key: KeyType) => string, equalsFn: (l: KeyType, r: KeyType) => boolean);
     /** Get a value for this key, or undefined if it does not exist. */
     get(key: KeyType): ValueType | undefined;
@@ -42,4 +44,5 @@ export declare class ObjectMap<KeyType, ValueType> {
     delete(key: KeyType): boolean;
     forEach(fn: (key: KeyType, val: ValueType) => void): void;
     isEmpty(): boolean;
+    size(): number;
 }

package/dist/firestore/test/unit/local/test_document_overlay_cache.d.ts

@@ -16,7 +16,7 @@
  */
 import { DocumentOverlayCache } from '../../../src/local/document_overlay_cache';
 import { Persistence } from '../../../src/local/persistence';
-import { DocumentKeySet } from '../../../src/model/collections';
+import { DocumentKeySet, MutationMap, OverlayMap } from '../../../src/model/collections';
 import { DocumentKey } from '../../../src/model/document_key';
 import { Mutation } from '../../../src/model/mutation';
 import { Overlay } from '../../../src/model/overlay';
@@ -29,10 +29,10 @@ export declare class TestDocumentOverlayCache {
     private persistence;
     private cache;
     constructor(persistence: Persistence, cache: DocumentOverlayCache);
-    saveOverlays(largestBatch: number, data: Map<DocumentKey, Mutation>): Promise<void>;
+    saveOverlays(largestBatch: number, data: MutationMap): Promise<void>;
     getOverlay(key: DocumentKey): Promise<Overlay | null>;
     getOverlayMutation(docKey: string): Promise<Mutation | null>;
-    getOverlaysForCollection(path: ResourcePath, sinceBatchId: number): Promise<Map<DocumentKey, Overlay>>;
-    getOverlaysForCollectionGroup(collectionGroup: string, sinceBatchId: number, count: number): Promise<Map<DocumentKey, Overlay>>;
+    getOverlaysForCollection(path: ResourcePath, sinceBatchId: number): Promise<OverlayMap>;
+    getOverlaysForCollectionGroup(collectionGroup: string, sinceBatchId: number, count: number): Promise<OverlayMap>;
     removeOverlaysForBatchId(documentKeys: DocumentKeySet, batchId: number): Promise<void>;
 }

package/dist/firestore/test/unit/local/test_index_manager.d.ts

@@ -34,7 +34,7 @@ export declare class TestIndexManager {
     deleteFieldIndex(index: FieldIndex): Promise<void>;
     getFieldIndexes(collectionGroup?: string): Promise<FieldIndex[]>;
     getFieldIndex(target: Target): Promise<FieldIndex | null>;
-    getDocumentsMatchingTarget(fieldIndex: FieldIndex, target: Target): Promise<DocumentKeySet>;
+    getDocumentsMatchingTarget(target: Target): Promise<DocumentKeySet | null>;
     getNextCollectionGroupToUpdate(): Promise<string | null>;
     updateCollectionGroup(collectionGroup: string, offset: IndexOffset): Promise<void>;
     updateIndexEntries(documents: DocumentMap): Promise<void>;

package/dist/firestore/test/unit/local/test_remote_document_cache.d.ts

@@ -21,6 +21,7 @@ import { RemoteDocumentChangeBuffer } from '../../../src/local/remote_document_c
 import { DocumentKeySet, MutableDocumentMap } from '../../../src/model/collections';
 import { MutableDocument } from '../../../src/model/document';
 import { DocumentKey } from '../../../src/model/document_key';
+import { IndexOffset } from '../../../src/model/field_index';
 import { ResourcePath } from '../../../src/model/path';
 /**
  * A wrapper around a RemoteDocumentCache that automatically creates a
@@ -44,7 +45,8 @@ export declare class TestRemoteDocumentCache {
     removeEntry(documentKey: DocumentKey, version?: SnapshotVersion): Promise<void>;
     getEntry(documentKey: DocumentKey): Promise<MutableDocument>;
     getEntries(documentKeys: DocumentKeySet): Promise<MutableDocumentMap>;
-    getAll(collection: ResourcePath, sinceReadTime: SnapshotVersion): Promise<MutableDocumentMap>;
+    getAllFromCollection(collection: ResourcePath, offset: IndexOffset): Promise<MutableDocumentMap>;
+    getAllFromCollectionGroup(collectionGroup: string, offset: IndexOffset, limit: number): Promise<MutableDocumentMap>;
     getNewDocumentChanges(sinceReadTime: SnapshotVersion): Promise<{
         changedDocs: MutableDocumentMap;
         readTime: SnapshotVersion;