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

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

@@ -15,10 +15,12 @@
  * limitations under the License.
  */
 import { BatchId, TargetId } from '../core/types';
+import { IndexKind } from '../model/field_index';
 import { ResourcePath } from '../model/path';
 import { BundledQuery } from '../protos/firestore_bundle_proto';
 import { Document as ProtoDocument, DocumentsTarget as ProtoDocumentsTarget, QueryTarget as ProtoQueryTarget, Write as ProtoWrite } from '../protos/firestore_proto_api';
 import { EncodedResourcePath } from './encoded_resource_path';
+export declare const INDEXING_SCHEMA_VERSION = 13;
 /**
  * Schema Version for the Web client:
  * 1.  Initial version including Mutation Queue, Query Cache, and Remote
@@ -37,8 +39,10 @@ import { EncodedResourcePath } from './encoded_resource_path';
  *     an auto-incrementing ID. This is required for Index-Free queries.
  * 10. Rewrite the canonical IDs to the explicit Protobuf-based format.
  * 11. Add bundles and named_queries for bundle support.
+ * 12. Add document overlays.
+ * 13. Add indexing support.
  */
-export declare const SCHEMA_VERSION = 11;
+export declare const SCHEMA_VERSION: number;
 /**
  * Wrapper class to store timestamps (seconds and nanos) in IndexedDb objects.
  */
@@ -763,9 +767,7 @@ export declare class DbClientMetadata {
 /** Object keys in the 'clientMetadata' store are clientId strings. */
 export declare type DbClientMetadataKey = string;
 export declare type DbBundlesKey = string;
-/**
- * A object representing a bundle loaded by the SDK.
- */
+/** An object representing a bundle loaded by the SDK. */
 export declare class DbBundle {
     /** The ID of the loaded bundle. */
     bundleId: string;
@@ -785,9 +787,7 @@ export declare class DbBundle {
     version: number);
 }
 export declare type DbNamedQueriesKey = string;
-/**
- * A object representing a named query loaded by the SDK via a bundle.
- */
+/** An object representing a named query loaded by the SDK via a bundle. */
 export declare class DbNamedQuery {
     /** The name of the query. */
     name: string;
@@ -806,15 +806,203 @@ export declare class DbNamedQuery {
     /** The query saved in the bundle. */
     bundledQuery: BundledQuery);
 }
+/** The key for each index consisting of just the index id. */
+export declare type DbIndexConfigurationKey = number;
+/** An object representing the global configuration for a field index. */
+export declare class DbIndexConfiguration {
+    /**
+     * The index id for this entry. Undefined for indexes that are not yet
+     * persisted.
+     */
+    indexId: number | undefined;
+    /** The collection group this index belongs to. */
+    collectionGroup: string;
+    /** The fields to index for this index. */
+    fields: Array<[name: string, kind: IndexKind]>;
+    /** Name of the IndexedDb object store. */
+    static store: string;
+    static keyPath: string;
+    /**
+     * 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.
+     */
+    static collectionGroupIndex: string;
+    static collectionGroupIndexPath: string;
+    constructor(
+    /**
+     * The index id for this entry. Undefined for indexes that are not yet
+     * persisted.
+     */
+    indexId: number | undefined, 
+    /** The collection group this index belongs to. */
+    collectionGroup: string, 
+    /** The fields to index for this index. */
+    fields: Array<[name: string, kind: IndexKind]>);
+}
+/** The key for each index state consisting of the index id and its user id. */
+export declare type DbIndexStateKey = [number, string];
+/**
+ * An object describing how up-to-date the index backfill is for each user and
+ * index.
+ */
+export declare class DbIndexState {
+    /** The index id for this entry. */
+    indexId: number;
+    /** The user id for this entry. */
+    uid: string;
+    /**
+     * A number that indicates when the index was last updated (relative to
+     * other indexes).
+     */
+    sequenceNumber: number;
+    /**
+     * The latest read time that has been indexed by Firestore for this field
+     * index. Set to `{seconds: 0, nanos: 0}` if no documents have been indexed.
+     */
+    readTime: DbTimestamp;
+    /**
+     * The last document that has been indexed for this field index. Empty if
+     * no documents have been indexed.
+     */
+    documentKey: EncodedResourcePath;
+    /**
+     * The largest mutation batch id that has been processed for this index. -1
+     * if no mutations have been indexed.
+     */
+    largestBatchId: number;
+    /** Name of the IndexedDb object store. */
+    static store: string;
+    static keyPath: string[];
+    /**
+     * 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.
+     */
+    static sequenceNumberIndex: string;
+    static sequenceNumberIndexPath: string[];
+    constructor(
+    /** The index id for this entry. */
+    indexId: number, 
+    /** The user id for this entry. */
+    uid: string, 
+    /**
+     * A number that indicates when the index was last updated (relative to
+     * other indexes).
+     */
+    sequenceNumber: number, 
+    /**
+     * The latest read time that has been indexed by Firestore for this field
+     * index. Set to `{seconds: 0, nanos: 0}` if no documents have been indexed.
+     */
+    readTime: DbTimestamp, 
+    /**
+     * The last document that has been indexed for this field index. Empty if
+     * no documents have been indexed.
+     */
+    documentKey: EncodedResourcePath, 
+    /**
+     * The largest mutation batch id that has been processed for this index. -1
+     * if no mutations have been indexed.
+     */
+    largestBatchId: number);
+}
+/**
+ * The key for each index entry consists of the index id and its user id,
+ * the encoded array and directional value for the indexed fields as well as
+ * the encoded document path for the indexed document.
+ */
+export declare type DbIndexEntryKey = [number, string, Uint8Array, Uint8Array, string];
+/** An object that stores the encoded entries for all documents and fields. */
+export declare class DbIndexEntry {
+    /** The index id for this entry. */
+    indexId: number;
+    /** The user id for this entry. */
+    uid: string;
+    /** The encoded array index value for this entry. */
+    arrayValue: Uint8Array;
+    /** The encoded directional value for equality and inequality filters. */
+    directionalValue: Uint8Array;
+    /** The document key this entry points to. */
+    documentKey: EncodedResourcePath;
+    /** Name of the IndexedDb object store. */
+    static store: string;
+    static keyPath: string[];
+    static documentKeyIndex: string;
+    static documentKeyIndexPath: string[];
+    constructor(
+    /** The index id for this entry. */
+    indexId: number, 
+    /** The user id for this entry. */
+    uid: string, 
+    /** The encoded array index value for this entry. */
+    arrayValue: Uint8Array, 
+    /** The encoded directional value for equality and inequality filters. */
+    directionalValue: Uint8Array, 
+    /** The document key this entry points to. */
+    documentKey: EncodedResourcePath);
+}
+export declare type DbDocumentOverlayKey = [
+    string,
+    string,
+    string
+];
+/**
+ * An object representing a document overlay.
+ */
+export declare class DbDocumentOverlay {
+    /** The user ID to whom this overlay belongs. */
+    userId: string;
+    /** The path to the collection that contains the document. */
+    collectionPath: string;
+    /** The ID (key) of the document within the collection. */
+    documentId: string;
+    /** The collection group to which the document belongs. */
+    collectionGroup: string;
+    /** The largest batch ID that's been applied for this overlay. */
+    largestBatchId: number;
+    /** The overlay mutation. */
+    overlayMutation: ProtoWrite;
+    /** Name of the IndexedDb object store. */
+    static store: string;
+    static keyPath: string[];
+    static collectionPathOverlayIndex: string;
+    static collectionPathOverlayIndexPath: string[];
+    static collectionGroupOverlayIndex: string;
+    static collectionGroupOverlayIndexPath: string[];
+    constructor(
+    /** The user ID to whom this overlay belongs. */
+    userId: string, 
+    /** The path to the collection that contains the document. */
+    collectionPath: string, 
+    /** The ID (key) of the document within the collection. */
+    documentId: string, 
+    /** The collection group to which the document belongs. */
+    collectionGroup: string, 
+    /** The largest batch ID that's been applied for this overlay. */
+    largestBatchId: number, 
+    /** The overlay mutation. */
+    overlayMutation: ProtoWrite);
+}
 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[];
 /**
  * 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/local_documents_view.d.ts

@@ -69,5 +69,4 @@ export declare class LocalDocumentsView {
     private getDocumentsMatchingDocumentQuery;
     private getDocumentsMatchingCollectionGroupQuery;
     private getDocumentsMatchingCollectionQuery;
-    private addMissingBaseDocuments;
 }

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

@@ -14,14 +14,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { User } from '../auth/user';
 import { BundleMetadata, NamedQuery } from '../core/bundle';
 import { Query } from '../core/query';
 import { SnapshotVersion } from '../core/snapshot_version';
 import { MutableDocument } from '../model/document';
+import { DocumentKey } from '../model/document_key';
+import { FieldIndex, IndexOffset } from '../model/field_index';
 import { MutationBatch } from '../model/mutation_batch';
-import { BundleMetadata as ProtoBundleMetadata, NamedQuery as ProtoNamedQuery, BundledQuery as ProtoBundledQuery } from '../protos/firestore_bundle_proto';
+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, DbMutationBatch, DbNamedQuery, DbRemoteDocument, DbTarget, DbTimestampKey } from './indexeddb_schema';
+import { DbBundle, DbDocumentOverlay, DbDocumentOverlayKey, DbIndexConfiguration, DbIndexState, DbMutationBatch, DbNamedQuery, DbRemoteDocument, DbTarget, DbTimestampKey } from './indexeddb_schema';
 import { TargetData } from './target_data';
 /** Serializer for values stored in the LocalStore. */
 export declare class LocalSerializer {
@@ -61,3 +65,15 @@ export declare function fromBundledQuery(bundledQuery: ProtoBundledQuery): Query
 export declare function fromProtoNamedQuery(namedQuery: ProtoNamedQuery): NamedQuery;
 /** Decodes a BundleMetadata proto into a BundleMetadata object. */
 export declare function fromBundleMetadata(metadata: ProtoBundleMetadata): BundleMetadata;
+/** Encodes a DbDocumentOverlay object to an Overlay model object. */
+export declare function fromDbDocumentOverlay(localSerializer: LocalSerializer, dbDocumentOverlay: DbDocumentOverlay): Overlay;
+/** Decodes an Overlay model object into a DbDocumentOverlay object. */
+export declare function toDbDocumentOverlay(localSerializer: LocalSerializer, userId: string, overlay: Overlay): DbDocumentOverlay;
+/**
+ * Returns the DbDocumentOverlayKey corresponding to the given user and
+ * document key.
+ */
+export declare function toDbDocumentOverlayKey(userId: string, docKey: DocumentKey): DbDocumentOverlayKey;
+export declare function toDbIndexConfiguration(index: FieldIndex): DbIndexConfiguration;
+export declare function fromDbIndexConfiguration(index: DbIndexConfiguration, state: DbIndexState | null): FieldIndex;
+export declare function toDbIndexState(indexId: number, user: User, sequenceNumber: number, offset: IndexOffset): DbIndexState;

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

@@ -0,0 +1,37 @@
+/**
+ * @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 { DocumentOverlayCache } from './document_overlay_cache';
+import { PersistencePromise } from './persistence_promise';
+import { PersistenceTransaction } from './persistence_transaction';
+/**
+ * An in-memory implementation of DocumentOverlayCache.
+ */
+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>;
+    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;
+}

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

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

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

@@ -19,6 +19,8 @@ import { ListenSequenceNumber, TargetId } from '../core/types';
 import { Document } from '../model/document';
 import { DocumentKey } from '../model/document_key';
 import { JsonProtoSerializer } from '../remote/serializer';
+import { DocumentOverlayCache } from './document_overlay_cache';
+import { IndexManager } from './index_manager';
 import { ActiveTargets, LruDelegate, LruGarbageCollector, LruParams } from './lru_garbage_collector';
 import { MemoryBundleCache } from './memory_bundle_cache';
 import { MemoryIndexManager } from './memory_index_manager';
@@ -43,6 +45,7 @@ export declare class MemoryPersistence implements Persistence {
      */
     private readonly indexManager;
     private mutationQueues;
+    private overlays;
     private readonly remoteDocumentCache;
     private readonly targetCache;
     private readonly bundleCache;
@@ -62,8 +65,9 @@ export declare class MemoryPersistence implements Persistence {
     get started(): boolean;
     setDatabaseDeletedListener(): void;
     setNetworkEnabled(): void;
-    getIndexManager(): MemoryIndexManager;
-    getMutationQueue(user: User): MutationQueue;
+    getIndexManager(user: User): MemoryIndexManager;
+    getDocumentOverlayCache(user: User): DocumentOverlayCache;
+    getMutationQueue(user: User, indexManager: IndexManager): MutationQueue;
     getTargetCache(): MemoryTargetCache;
     getRemoteDocumentCache(): MemoryRemoteDocumentCache;
     getBundleCache(): MemoryBundleCache;

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

@@ -16,7 +16,6 @@
  */
 import { Document } from '../model/document';
 import { DocumentKey } from '../model/document_key';
-import { IndexManager } from './index_manager';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
 import { RemoteDocumentCache } from './remote_document_cache';
@@ -27,9 +26,8 @@ export interface MemoryRemoteDocumentCache extends RemoteDocumentCache {
 /**
  * Creates a new memory-only RemoteDocumentCache.
  *
- * @param indexManager - A class that manages collection group indices.
  * @param sizer - Used to assess the size of a document. For eager GC, this is
  * expected to just return 0 to avoid unnecessarily doing the work of
  * calculating the size.
  */
-export declare function newMemoryRemoteDocumentCache(indexManager: IndexManager, sizer: DocumentSizer): MemoryRemoteDocumentCache;
+export declare function newMemoryRemoteDocumentCache(sizer: DocumentSizer): MemoryRemoteDocumentCache;

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

@@ -18,6 +18,7 @@ import { User } from '../auth/user';
 import { TargetId } from '../core/types';
 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';
@@ -140,7 +141,7 @@ export interface Persistence {
      * extent possible (e.g. in the case of uid switching from
      * sally=>jack=>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.
      *
@@ -173,7 +174,12 @@ export 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

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

@@ -14,11 +14,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Query } from '../core/query';
 import { SnapshotVersion } from '../core/snapshot_version';
 import { DocumentKeySet, MutableDocumentMap } from '../model/collections';
 import { MutableDocument } from '../model/document';
 import { DocumentKey } from '../model/document_key';
+import { ResourcePath } from '../model/path';
+import { IndexManager } from './index_manager';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
 import { RemoteDocumentChangeBuffer } from './remote_document_change_buffer';
@@ -30,6 +31,8 @@ import { RemoteDocumentChangeBuffer } from './remote_document_change_buffer';
  * documents that are known to not exist.
  */
 export interface RemoteDocumentCache {
+    /** Sets the index manager to use for managing the collectionGroup index. */
+    setIndexManager(indexManager: IndexManager): void;
     /**
      * Looks up an entry in the cache.
      *
@@ -47,19 +50,14 @@ export interface RemoteDocumentCache {
      */
     getEntries(transaction: PersistenceTransaction, documentKeys: DocumentKeySet): PersistencePromise<MutableDocumentMap>;
     /**
-     * Executes a query against the cached Document entries.
+     * Returns the documents from the provided collection.
      *
-     * 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.
-     *
-     * @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, 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/firestore/src/local/simple_db.d.ts

@@ -36,6 +36,7 @@ export declare class SimpleDbTransaction {
     constructor(action: string, transaction: IDBTransaction);
     get completionPromise(): Promise<void>;
     abort(error?: Error): void;
+    maybeCommit(): void;
     /**
      * Returns a SimpleDbStore<KeyType, ValueType> for the specified store. All
      * operations performed on the SimpleDbStore happen within the context of this

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

@@ -24,8 +24,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;

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

@@ -43,7 +43,7 @@ export declare class FieldIndex {
     /** The collection ID this index applies to. */
     readonly collectionGroup: string;
     /** The field segments for this index. */
-    readonly segments: IndexSegment[];
+    readonly fields: IndexSegment[];
     /** Shows how up-to-date the index is for the current user. */
     readonly indexState: IndexState;
     /** An ID for an index that has not yet been added to persistence.  */
@@ -57,7 +57,7 @@ export declare class FieldIndex {
     /** The collection ID this index applies to. */
     collectionGroup: string, 
     /** The field segments for this index. */
-    segments: IndexSegment[], 
+    fields: IndexSegment[], 
     /** Shows how up-to-date the index is for the current user. */
     indexState: IndexState);
 }

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

@@ -0,0 +1,32 @@
+/**
+ * @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 './document_key';
+import { Mutation } from './mutation';
+/**
+ * Representation of an overlay computed by Firestore.
+ *
+ * Holds information about a mutation and the largest batch id in Firestore when
+ * the mutation was created.
+ */
+export declare class Overlay {
+    readonly largestBatchId: number;
+    readonly mutation: Mutation;
+    constructor(largestBatchId: number, mutation: Mutation);
+    getKey(): DocumentKey;
+    isEqual(other: Overlay | null): boolean;
+    toString(): string;
+}

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

@@ -0,0 +1,70 @@
+/**
+ * @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 { Target } from '../core/target';
+import { FieldIndex } from './field_index';
+/**
+ * A light query planner for Firestore.
+ *
+ * This class matches a `FieldIndex` against a Firestore Query `Target`. It
+ * determines whether a given index can be used to serve the specified target.
+ *
+ * The following table showcases some possible index configurations:
+ *
+ * Query                                               | Index
+ * -----------------------------------------------------------------------------
+ * where('a', '==', 'a').where('b', '==', 'b')         | a ASC, b DESC
+ * where('a', '==', 'a').where('b', '==', 'b')         | a ASC
+ * where('a', '==', 'a').where('b', '==', 'b')         | b DESC
+ * where('a', '>=', 'a').orderBy('a')                  | a ASC
+ * where('a', '>=', 'a').orderBy('a', 'desc')          | a DESC
+ * where('a', '>=', 'a').orderBy('a').orderBy('b')     | a ASC, b ASC
+ * where('a', '>=', 'a').orderBy('a').orderBy('b')     | a ASC
+ * where('a', 'array-contains', 'a').orderBy('b')      | a CONTAINS, b ASCENDING
+ * where('a', 'array-contains', 'a').orderBy('b')      | a CONTAINS
+ */
+export declare class TargetIndexMatcher {
+    private readonly collectionId;
+    private readonly inequalityFilter?;
+    private readonly equalityFilters;
+    private readonly orderBys;
+    constructor(target: Target);
+    /**
+     * Returns whether the index can be used to serve the TargetIndexMatcher's
+     * target.
+     *
+     * An index is considered capable of serving the target when:
+     * - The target uses all index segments for its filters and orderBy clauses.
+     *   The target can have additional filter and orderBy clauses, but not
+     *   fewer.
+     * - If an ArrayContains/ArrayContainsAnyfilter is used, the index must also
+     *   have a corresponding `CONTAINS` segment.
+     * - All directional index segments can be mapped to the target as a series of
+     *   equality filters, a single inequality filter and a series of orderBy
+     *   clauses.
+     * - The segments that represent the equality filters may appear out of order.
+     * - The optional segment for the inequality filter must appear after all
+     *   equality segments.
+     * - The segments that represent that orderBy clause of the target must appear
+     *   in order after all equality and inequality segments. Single orderBy
+     *   clauses cannot be skipped, but a continuous orderBy suffix may be
+     *   omitted.
+     */
+    servedByIndex(index: FieldIndex): boolean;
+    private hasMatchingEqualityFilter;
+    private matchesFilter;
+    private matchesOrderBy;
+}

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

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { GrpcObject } from '@grpc/grpc-js';
+import * as grpc from '@grpc/grpc-js';
 import { Token } from '../../api/credentials';
 import { DatabaseInfo } from '../../core/database_info';
 import { Connection, Stream } from '../../remote/connection';
@@ -26,7 +26,7 @@ export declare class GrpcConnection implements Connection {
     private readonly databasePath;
     private readonly firestore;
     private cachedStub;
-    constructor(protos: GrpcObject, databaseInfo: DatabaseInfo);
+    constructor(protos: grpc.GrpcObject, databaseInfo: DatabaseInfo);
     private ensureActiveStub;
     invokeRPC<Req, Resp>(rpcName: string, path: string, request: Req, authToken: Token | null, appCheckToken: Token | null): Promise<Resp>;
     invokeStreamingRPC<Req, Resp>(rpcName: string, path: string, request: Req, authToken: Token | null, appCheckToken: Token | null): Promise<Resp[]>;