@firebase/firestore 3.4.9-canary.f84cacd70 → 3.4.10

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @firebase/firestore
 
+## 3.4.10
+
+### Patch Changes
+
+- [`2cd1cc76f`](https://github.com/firebase/firebase-js-sdk/commit/2cd1cc76f2a308135cd60f424fe09084a34b5cb5) [#6307](https://github.com/firebase/firebase-js-sdk/pull/6307) (fixes [#6300](https://github.com/firebase/firebase-js-sdk/issues/6300)) - fix: add type declarations to exports field
+
+* [`d4b52b612`](https://github.com/firebase/firebase-js-sdk/commit/d4b52b612cf73610c57a3c08a0415ab7b622a70a) [#6321](https://github.com/firebase/firebase-js-sdk/pull/6321) - Fix incorrect paths in package.json
+
+* Updated dependencies [[`2cd1cc76f`](https://github.com/firebase/firebase-js-sdk/commit/2cd1cc76f2a308135cd60f424fe09084a34b5cb5)]:
+  - @firebase/component@0.5.15
+  - @firebase/logger@0.3.3
+  - @firebase/util@1.6.1
+  - @firebase/webchannel-wrapper@0.6.2
+
 ## 3.4.9
 
 ### Patch Changes

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

@@ -18,7 +18,7 @@ import { CredentialsProvider } from '../api/credentials';
 import { User } from '../auth/user';
 import { IndexedDbPersistence } from '../local/indexeddb_persistence';
 import { LocalStore } from '../local/local_store';
-import { GarbageCollectionScheduler, Persistence } from '../local/persistence';
+import { Scheduler, Persistence } from '../local/persistence';
 import { ClientId, SharedClientState } from '../local/shared_client_state';
 import { Datastore } from '../remote/datastore';
 import { RemoteStore } from '../remote/remote_store';
@@ -44,7 +44,8 @@ export interface OfflineComponentProvider {
     persistence: Persistence;
     sharedClientState: SharedClientState;
     localStore: LocalStore;
-    gcScheduler: GarbageCollectionScheduler | null;
+    gcScheduler: Scheduler | null;
+    indexBackfillerScheduler: Scheduler | null;
     synchronizeTabs: boolean;
     initialize(cfg: ComponentConfiguration): Promise<void>;
     terminate(): Promise<void>;
@@ -57,11 +58,13 @@ export declare class MemoryOfflineComponentProvider implements OfflineComponentP
     persistence: Persistence;
     sharedClientState: SharedClientState;
     localStore: LocalStore;
-    gcScheduler: GarbageCollectionScheduler | null;
+    gcScheduler: Scheduler | null;
+    indexBackfillerScheduler: Scheduler | null;
     synchronizeTabs: boolean;
     serializer: JsonProtoSerializer;
     initialize(cfg: ComponentConfiguration): Promise<void>;
-    createGarbageCollectionScheduler(cfg: ComponentConfiguration): GarbageCollectionScheduler | null;
+    createGarbageCollectionScheduler(cfg: ComponentConfiguration, localStore: LocalStore): Scheduler | null;
+    createIndexBackfillerScheduler(cfg: ComponentConfiguration, localStore: LocalStore): Scheduler | null;
     createLocalStore(cfg: ComponentConfiguration): LocalStore;
     createPersistence(cfg: ComponentConfiguration): Persistence;
     createSharedClientState(cfg: ComponentConfiguration): SharedClientState;
@@ -77,12 +80,14 @@ export declare class IndexedDbOfflineComponentProvider extends MemoryOfflineComp
     persistence: IndexedDbPersistence;
     sharedClientState: SharedClientState;
     localStore: LocalStore;
-    gcScheduler: GarbageCollectionScheduler | null;
+    gcScheduler: Scheduler | null;
+    indexBackfillerScheduler: Scheduler | null;
     synchronizeTabs: boolean;
     constructor(onlineComponentProvider: OnlineComponentProvider, cacheSizeBytes: number | undefined, forceOwnership: boolean | undefined);
     initialize(cfg: ComponentConfiguration): Promise<void>;
     createLocalStore(cfg: ComponentConfiguration): LocalStore;
-    createGarbageCollectionScheduler(cfg: ComponentConfiguration): GarbageCollectionScheduler | null;
+    createGarbageCollectionScheduler(cfg: ComponentConfiguration, localStore: LocalStore): Scheduler | null;
+    createIndexBackfillerScheduler(cfg: ComponentConfiguration, localStore: LocalStore): Scheduler | null;
     createPersistence(cfg: ComponentConfiguration): IndexedDbPersistence;
     createSharedClientState(cfg: ComponentConfiguration): SharedClientState;
 }

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

@@ -40,7 +40,7 @@ export interface DocumentOverlayCache {
      * Gets the saved overlay mutation for the given document keys. Skips keys for
      * which there are no overlays.
      */
-    getOverlays(transaction: PersistenceTransaction, keys: DocumentKeySet): PersistencePromise<OverlayMap>;
+    getOverlays(transaction: PersistenceTransaction, keys: DocumentKey[]): PersistencePromise<OverlayMap>;
     /**
      * Saves the given document mutation map to persistence as overlays.
      * All overlays will have their largest batch id set to `largestBatchId`.

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

@@ -0,0 +1,44 @@
+import { AsyncQueue } from '../util/async_queue';
+import { LocalStore } from './local_store';
+import { Persistence, Scheduler } from './persistence';
+/** This class is responsible for the scheduling of Index Backfiller. */
+export declare class IndexBackfillerScheduler implements Scheduler {
+    private readonly asyncQueue;
+    private readonly backfiller;
+    private task;
+    constructor(asyncQueue: AsyncQueue, backfiller: IndexBackfiller);
+    start(): void;
+    stop(): void;
+    get started(): boolean;
+    private schedule;
+}
+/** Implements the steps for backfilling indexes. */
+export declare class IndexBackfiller {
+    /**
+     * LocalStore provides access to IndexManager and LocalDocumentView.
+     * These properties will update when the user changes. Consequently,
+     * making a local copy of IndexManager and LocalDocumentView will require
+     * updates over time. The simpler solution is to rely on LocalStore to have
+     * an up-to-date references to IndexManager and LocalDocumentStore.
+     */
+    private readonly localStore;
+    private readonly persistence;
+    constructor(
+    /**
+     * LocalStore provides access to IndexManager and LocalDocumentView.
+     * These properties will update when the user changes. Consequently,
+     * making a local copy of IndexManager and LocalDocumentView will require
+     * updates over time. The simpler solution is to rely on LocalStore to have
+     * an up-to-date references to IndexManager and LocalDocumentStore.
+     */
+    localStore: LocalStore, persistence: Persistence);
+    backfill(maxDocumentsToProcess?: number): Promise<number>;
+    /** Writes index entries until the cap is reached. Returns the number of documents processed. */
+    private writeIndexEntries;
+    /**
+     * Writes entries for the provided collection group. Returns the number of documents processed.
+     */
+    private writeEntriesForCollectionGroup;
+    /** Returns the next offset based on the provided documents. */
+    private getNewOffset;
+}

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

@@ -114,4 +114,6 @@ export interface IndexManager {
      * and returns the minimum offset of them all.
      */
     getMinOffset(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexOffset>;
+    /** Returns the minimum offset for the given collection group. */
+    getMinOffsetFromCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string): PersistencePromise<IndexOffset>;
 }

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

@@ -36,7 +36,7 @@ export declare class IndexedDbDocumentOverlayCache implements DocumentOverlayCac
     constructor(serializer: LocalSerializer, userId: string);
     static forUser(serializer: LocalSerializer, user: User): IndexedDbDocumentOverlayCache;
     getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
-    getOverlays(transaction: PersistenceTransaction, keys: DocumentKeySet): PersistencePromise<OverlayMap>;
+    getOverlays(transaction: PersistenceTransaction, keys: DocumentKey[]): PersistencePromise<OverlayMap>;
     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<OverlayMap>;

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

@@ -128,5 +128,6 @@ export declare class IndexedDbIndexManager implements IndexManager {
      * '[foo > 2 && foo != 3]` becomes  `[foo > 2 && < 3, foo > 3]`.
      */
     private createRange;
+    getMinOffsetFromCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string): PersistencePromise<IndexOffset>;
     getMinOffset(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexOffset>;
 }

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

@@ -15,15 +15,15 @@
  * limitations under the License.
  */
 import { Query } from '../core/query';
-import { DocumentKeySet, OverlayMap, DocumentMap, MutableDocumentMap, DocumentKeyMap } from '../model/collections';
+import { DocumentKeySet, OverlayMap, DocumentMap, MutableDocumentMap, DocumentKeyMap, OverlayedDocumentMap } from '../model/collections';
 import { Document } from '../model/document';
 import { DocumentKey } from '../model/document_key';
 import { IndexOffset } from '../model/field_index';
 import { FieldMask } from '../model/field_mask';
 import { DocumentOverlayCache } from './document_overlay_cache';
 import { IndexManager } from './index_manager';
+import { LocalWriteResult } from './local_store_impl';
 import { MutationQueue } from './mutation_queue';
-import { OverlayedDocument } from './overlayed_document';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
 import { RemoteDocumentCache } from './remote_document_cache';
@@ -69,7 +69,7 @@ export declare class LocalDocumentsView {
      * the local view of those documents and a `FieldMask` indicating which fields
      * are mutated locally, `null` if overlay is a Set or Delete mutation.
      */
-    getOverlayedDocuments(transaction: PersistenceTransaction, docs: MutableDocumentMap): PersistencePromise<DocumentKeyMap<OverlayedDocument>>;
+    getOverlayedDocuments(transaction: PersistenceTransaction, docs: MutableDocumentMap): PersistencePromise<OverlayedDocumentMap>;
     /**
      * Fetches the overlays for {@code docs} and adds them to provided overlay map
      * if the map does not already contain an entry for the given document key.
@@ -87,7 +87,7 @@ export declare class LocalDocumentsView {
      *   overlays from mutation queues.
      * @return A map represents the local documents view.
      */
-    computeViews(transaction: PersistenceTransaction, docs: MutableDocumentMap, overlays: OverlayMap, existenceStateChanged: DocumentKeySet): PersistencePromise<DocumentKeyMap<OverlayedDocument>>;
+    computeViews(transaction: PersistenceTransaction, docs: MutableDocumentMap, overlays: OverlayMap, existenceStateChanged: DocumentKeySet): PersistencePromise<OverlayedDocumentMap>;
     private recalculateAndSaveOverlays;
     /**
      * Recalculates overlays by reading the documents from remote document cache
@@ -102,6 +102,22 @@ export declare class LocalDocumentsView {
      * @param offset - Read time and key to start scanning by (exclusive).
      */
     getDocumentsMatchingQuery(transaction: PersistenceTransaction, query: Query, offset: IndexOffset): PersistencePromise<DocumentMap>;
+    /**
+     * Given a collection group, returns the next documents that follow the provided offset, along
+     * with an updated batch ID.
+     *
+     * <p>The documents returned by this method are ordered by remote version from the provided
+     * offset. If there are no more remote documents after the provided offset, documents with
+     * mutations in order of batch id from the offset are returned. Since all documents in a batch are
+     * returned together, the total number of documents returned can exceed {@code count}.
+     *
+     * @param transaction
+     * @param collectionGroup The collection group for the documents.
+     * @param offset The offset to index into.
+     * @param count The number of documents to return
+     * @return A LocalWriteResult with the documents that follow the provided offset and the last processed batch id.
+     */
+    getNextDocuments(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset, count: number): PersistencePromise<LocalWriteResult>;
     private getDocumentsMatchingDocumentQuery;
     private getDocumentsMatchingCollectionGroupQuery;
     private getDocumentsMatchingCollectionQuery;

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

@@ -15,9 +15,18 @@
  * limitations under the License.
  */
 import { FirestoreError } from '../util/error';
+import { IndexManager } from './index_manager';
+import { LocalDocumentsView } from './local_documents_view';
 import { LruGarbageCollector, LruResults } from './lru_garbage_collector';
 export interface LocalStore {
     collectGarbage(garbageCollector: LruGarbageCollector): Promise<LruResults>;
+    /** Manages the list of active field and collection indices. */
+    indexManager: IndexManager;
+    /**
+     * The "local" view of all documents (layering mutationQueue on top of
+     * remoteDocumentCache).
+     */
+    localDocuments: LocalDocumentsView;
 }
 /**
  * Verifies the error thrown by a LocalStore operation. If a LocalStore

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

@@ -17,19 +17,19 @@
 import { AsyncQueue } from '../util/async_queue';
 import { LocalStore } from './local_store';
 import { LruDelegate, LruGarbageCollector, LruParams } from './lru_garbage_collector';
-import { GarbageCollectionScheduler } from './persistence';
+import { Scheduler } from './persistence';
 export declare const LRU_MINIMUM_CACHE_SIZE_BYTES: number;
 /**
  * This class is responsible for the scheduling of LRU garbage collection. It handles checking
  * whether or not GC is enabled, as well as which delay to use before the next run.
  */
-export declare class LruScheduler implements GarbageCollectionScheduler {
+export declare class LruScheduler implements Scheduler {
     private readonly garbageCollector;
     private readonly asyncQueue;
-    private hasRun;
+    private readonly localStore;
     private gcTask;
-    constructor(garbageCollector: LruGarbageCollector, asyncQueue: AsyncQueue);
-    start(localStore: LocalStore): void;
+    constructor(garbageCollector: LruGarbageCollector, asyncQueue: AsyncQueue, localStore: LocalStore);
+    start(): void;
     stop(): void;
     get started(): boolean;
     private scheduleGC;

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

@@ -28,7 +28,7 @@ export declare class MemoryDocumentOverlayCache implements DocumentOverlayCache
     private overlays;
     private overlayByBatchId;
     getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
-    getOverlays(transaction: PersistenceTransaction, keys: DocumentKeySet): PersistencePromise<OverlayMap>;
+    getOverlays(transaction: PersistenceTransaction, keys: DocumentKey[]): PersistencePromise<OverlayMap>;
     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<OverlayMap>;

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

@@ -36,6 +36,7 @@ export declare class MemoryIndexManager implements IndexManager {
     getFieldIndexes(transaction: PersistenceTransaction, collectionGroup?: string): PersistencePromise<FieldIndex[]>;
     getNextCollectionGroupToUpdate(transaction: PersistenceTransaction): PersistencePromise<string | null>;
     getMinOffset(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexOffset>;
+    getMinOffsetFromCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string): PersistencePromise<IndexOffset>;
     updateCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset): PersistencePromise<void>;
     updateIndexEntries(transaction: PersistenceTransaction, documents: DocumentMap): PersistencePromise<void>;
 }

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

@@ -20,7 +20,6 @@ import { DocumentKey } from '../model/document_key';
 import { BundleCache } from './bundle_cache';
 import { DocumentOverlayCache } from './document_overlay_cache';
 import { IndexManager } from './index_manager';
-import { LocalStore } from './local_store';
 import { MutationQueue } from './mutation_queue';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction, PersistenceTransactionMode } from './persistence_transaction';
@@ -204,11 +203,10 @@ export interface Persistence {
     runTransaction<T>(action: string, mode: PersistenceTransactionMode, transactionOperation: (transaction: PersistenceTransaction) => PersistencePromise<T>): Promise<T>;
 }
 /**
- * Interface implemented by the LRU scheduler to start(), stop() and restart
- * garbage collection.
+ * Interface to schedule periodic tasks within SDK.
  */
-export interface GarbageCollectionScheduler {
+export interface Scheduler {
     readonly started: boolean;
-    start(localStore: LocalStore): void;
+    start(): void;
     stop(): void;
 }

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

@@ -69,4 +69,15 @@ export declare class PersistencePromise<T> {
     static forEach<R>(collection: {
         forEach: (cb: (r: R) => void) => void;
     }, f: (r: R) => PersistencePromise<void>): PersistencePromise<void>;
+    /**
+     * Concurrently map all array elements through asynchronous function.
+     */
+    static mapArray<T, U>(array: T[], f: (t: T) => PersistencePromise<U>): PersistencePromise<U[]>;
+    /**
+     * An alternative to recursive PersistencePromise calls, that avoids
+     * potential memory problems from unbounded chains of promises.
+     *
+     * The `action` will be called repeatedly while `condition` is true.
+     */
+    static doWhile(condition: () => boolean, action: () => PersistencePromise<void>): PersistencePromise<void>;
 }

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

@@ -16,6 +16,7 @@
  */
 import { SnapshotVersion } from '../core/snapshot_version';
 import { TargetId } from '../core/types';
+import { OverlayedDocument } from '../local/overlayed_document';
 import { ObjectMap } from '../util/obj_map';
 import { SortedMap } from '../util/sorted_map';
 import { SortedSet } from '../util/sorted_set';
@@ -32,9 +33,12 @@ export interface DocumentSizeEntries {
 }
 export declare type DocumentMap = SortedMap<DocumentKey, Document>;
 export declare function documentMap(...docs: Document[]): DocumentMap;
-export declare type OverlayMap = ObjectMap<DocumentKey, Overlay>;
+export declare type OverlayedDocumentMap = DocumentKeyMap<OverlayedDocument>;
+export declare function newOverlayedDocumentMap(): OverlayedDocumentMap;
+export declare function convertOverlayedDocumentMapToDocumentMap(collection: OverlayedDocumentMap): DocumentMap;
+export declare type OverlayMap = DocumentKeyMap<Overlay>;
 export declare function newOverlayMap(): OverlayMap;
-export declare type MutationMap = ObjectMap<DocumentKey, Mutation>;
+export declare type MutationMap = DocumentKeyMap<Mutation>;
 export declare function newMutationMap(): MutationMap;
 export declare type DocumentKeyMap<T> = ObjectMap<DocumentKey, T>;
 export declare function newDocumentKeyMap<T>(): DocumentKeyMap<T>;

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

@@ -17,8 +17,7 @@
 import { SnapshotVersion } from '../core/snapshot_version';
 import { BatchId } from '../core/types';
 import { Timestamp } from '../lite-api/timestamp';
-import { OverlayedDocument } from '../local/overlayed_document';
-import { DocumentKeySet, MutationMap, DocumentVersionMap, DocumentKeyMap } from './collections';
+import { DocumentKeySet, MutationMap, DocumentVersionMap, OverlayedDocumentMap } from './collections';
 import { MutableDocument } from './document';
 import { FieldMask } from './field_mask';
 import { Mutation, MutationResult } from './mutation';
@@ -65,7 +64,7 @@ export declare class MutationBatch {
      * this batch. Returns a `DocumentKey` to `Mutation` map which can be used to
      * replace all the mutation applications.
      */
-    applyToLocalDocumentSet(documentMap: DocumentKeyMap<OverlayedDocument>, documentsWithoutRemoteVersion: DocumentKeySet): MutationMap;
+    applyToLocalDocumentSet(documentMap: OverlayedDocumentMap, documentsWithoutRemoteVersion: DocumentKeySet): MutationMap;
     keys(): DocumentKeySet;
     isEqual(other: MutationBatch): boolean;
 }

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

@@ -59,7 +59,11 @@ export declare const enum TimerId {
      * A timer used to retry operations scheduled via retryable AsyncQueue
      * operations.
      */
-    AsyncQueueRetry = "async_queue_retry"
+    AsyncQueueRetry = "async_queue_retry",
+    /**
+     *  A timer used to periodically attempt index backfill.
+     */
+    IndexBackfill = "index_backfill"
 }
 /**
  * Represents an operation scheduled to be run in the future on an AsyncQueue.

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

@@ -0,0 +1,17 @@
+/**
+ * @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.
+ */
+export {};

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

@@ -31,7 +31,7 @@ export declare class TestDocumentOverlayCache {
     constructor(persistence: Persistence, cache: DocumentOverlayCache);
     saveOverlays(largestBatch: number, data: MutationMap): Promise<void>;
     getOverlay(key: DocumentKey): Promise<Overlay | null>;
-    getOverlays(keys: DocumentKeySet): Promise<OverlayMap>;
+    getOverlays(keys: DocumentKey[]): Promise<OverlayMap>;
     getOverlayMutation(docKey: string): Promise<Mutation | null>;
     getOverlaysForCollection(path: ResourcePath, sinceBatchId: number): Promise<OverlayMap>;
     getOverlaysForCollectionGroup(collectionGroup: string, sinceBatchId: number, count: number): Promise<OverlayMap>;

package/dist/firestore/test/unit/specs/spec_test_components.d.ts

@@ -20,8 +20,9 @@ import { Observer } from '../../../src/core/event_manager';
 import { Query } from '../../../src/core/query';
 import { ViewSnapshot } from '../../../src/core/view_snapshot';
 import { IndexedDbPersistence } from '../../../src/local/indexeddb_persistence';
+import { LocalStore } from '../../../src/local/local_store';
 import { MemoryPersistence } from '../../../src/local/memory_persistence';
-import { GarbageCollectionScheduler, Persistence } from '../../../src/local/persistence';
+import { Scheduler, Persistence } from '../../../src/local/persistence';
 import { PersistencePromise } from '../../../src/local/persistence_promise';
 import { PersistenceTransaction, PersistenceTransactionMode } from '../../../src/local/persistence_transaction';
 import { SharedClientState } from '../../../src/local/shared_client_state';
@@ -62,7 +63,8 @@ export declare class MockMultiTabOfflineComponentProvider extends MultiTabOfflin
     private readonly document;
     persistence: MockIndexedDbPersistence;
     constructor(window: WindowLike, document: FakeDocument, onlineComponentProvider: OnlineComponentProvider);
-    createGarbageCollectionScheduler(cfg: ComponentConfiguration): GarbageCollectionScheduler | null;
+    createGarbageCollectionScheduler(cfg: ComponentConfiguration, localStore: LocalStore): Scheduler | null;
+    createIndexBackfillerScheduler(cfg: ComponentConfiguration, localStore: LocalStore): Scheduler | null;
     createSharedClientState(cfg: ComponentConfiguration): SharedClientState;
     createPersistence(cfg: ComponentConfiguration): MockIndexedDbPersistence;
 }
@@ -71,7 +73,7 @@ export declare class MockMemoryOfflineComponentProvider extends MemoryOfflineCom
     persistence: MockMemoryPersistence;
     connection: MockConnection;
     constructor(gcEnabled: boolean);
-    createGarbageCollectionScheduler(cfg: ComponentConfiguration): GarbageCollectionScheduler | null;
+    createGarbageCollectionScheduler(cfg: ComponentConfiguration): Scheduler | null;
     createPersistence(cfg: ComponentConfiguration): Persistence;
 }
 export declare class MockConnection implements Connection {

package/dist/firestore/test/util/helpers.d.ts

@@ -63,6 +63,7 @@ export declare function fieldIndex(collectionGroup: string, options?: {
     id?: number;
     fields?: Array<[field: string, kind: IndexKind]>;
     offset?: IndexOffset;
+    sequenceNumber?: number;
 }): FieldIndex;
 export declare function mask(...paths: string[]): FieldMask;
 export declare function blob(...bytes: number[]): Bytes;