@firebase/firestore 3.4.8-canary.7b58dabdf → 3.4.8-canary.874cdbbcc

package/dist/lite/internal.d.ts

@@ -2110,7 +2110,7 @@ declare class ResourcePath extends BasePath<ResourcePath> {
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a
  * rejected promise with the corresponding failure error is returned.
  */
-export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>): Promise<T>;
+export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
 
 /**
  * Returns a sentinel used with {@link @firebase/firestore/lite#(setDoc:1)} or {@link @firebase/firestore/lite#(updateDoc:1)} to
@@ -2615,6 +2615,30 @@ declare class Transaction_2 {
     private ensureCommitNotCalled;
 }
 
+/**
+ * @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.
+ */
+/**
+ * Options to customize transaction behavior.
+ */
+export declare interface TransactionOptions {
+    /** Maximum number of attempts to commit, after which transaction fails. Default is 5. */
+    readonly maxAttempts?: number;
+}
+
 /** Used to represent a field transform on a mutation. */
 declare class TransformOperation {
     private _;

package/dist/lite/packages/firestore/dist/lite/index.browser.esm2017.d.ts

@@ -536,7 +536,7 @@ declare class gt {
      * to be compared using the `>`, `<=`, `>=` and `>` operators.
      */ valueOf(): string;
 }
-declare class Ur {
+declare class kr {
     /** @hideconstructor */
     constructor(t: any, e: any);
     _firestore: any;
@@ -548,14 +548,14 @@ declare class Ur {
      * @param documentRef - A reference to the document to be read.
      * @returns A `DocumentSnapshot` with the read data.
      */ get(t: any): any;
-    set(t: any, e: any, n: any): Ur;
-    update(t: any, e: any, n: any, ...r: any[]): Ur;
+    set(t: any, e: any, n: any): kr;
+    update(t: any, e: any, n: any, ...r: any[]): kr;
     /**
      * Deletes the document referred to by the provided {@link DocumentReference}.
      *
      * @param documentRef - A reference to the document to be deleted.
      * @returns This `Transaction` instance. Used for chaining method calls.
-     */ delete(t: any): Ur;
+     */ delete(t: any): kr;
 }
 /**
  * @license
@@ -624,7 +624,7 @@ declare class Ur {
  * @throws Error - If the provided input is not a valid Firestore document.
  * @returns A `Promise` resolved with a `DocumentReference` pointing to the
  * newly created document after it has been written to the backend.
- */ declare function Ar(t: any, e: any): Promise<an>;
+ */ declare function Ir(t: any, e: any): Promise<an>;
 /**
  * Returns a special value that can be used with {@link (setDoc:1)} or {@link
  * updateDoc:1} that tells the server to remove the given elements from any
@@ -635,7 +635,7 @@ declare class Ur {
  * @param elements - The elements to remove from the array.
  * @returns The `FieldValue` sentinel for use in a call to `setDoc()` or
  * `updateDoc()`
- */ declare function Dr(...t: any[]): xn;
+ */ declare function Dr(...t: any[]): Fn;
 /**
  * Returns a special value that can be used with {@link @firebase/firestore/lite#(setDoc:1)} or {@link
  * @firebase/firestore/lite#(updateDoc:1)} that tells the server to union the given elements with any array
@@ -647,7 +647,7 @@ declare class Ur {
  * @param elements - The elements to union into the array.
  * @returns The `FieldValue` sentinel for use in a call to `setDoc()` or
  * `updateDoc()`.
- */ declare function Vr(...t: any[]): Fn;
+ */ declare function Vr(...t: any[]): xn;
 declare function fn(t: any, e: any, ...n: any[]): ln;
 /**
  * Creates and returns a new `Query` instance that includes all documents in the
@@ -684,7 +684,7 @@ declare function fn(t: any, e: any, ...n: any[]): ln;
  * @param reference - A reference to the document to delete.
  * @returns A `Promise` resolved once the document has been successfully
  * deleted from the backend.
- */ declare function Ir(t: any): Promise<void>;
+ */ declare function Ar(t: any): Promise<void>;
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -832,7 +832,7 @@ declare function sn(t: any, e: any): import("../../lite").Firestore;
  * (the `updateFunction` returned a failed promise), the promise returned by the
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a
  * rejected promise with the corresponding failure error is returned.
- */ declare function kr(t: any, e: any): Promise<any>;
+ */ declare function jr(t: any, e: any, n: any): Promise<any>;
 /**
  * Returns a sentinel used with {@link @firebase/firestore/lite#(setDoc:1)} or {@link @firebase/firestore/lite#(updateDoc:1)} to
  * include a server-generated timestamp in the written data.
@@ -904,7 +904,7 @@ declare function Tr(t: any, e: any, n: any, ...r: any[]): Promise<void>;
  *
  * @returns A `WriteBatch` that can be used to atomically execute multiple
  * writes.
- */ declare function Fr(t: any): $r;
+ */ declare function xr(t: any): $r;
 /**
  * A dot-separated path for navigating sub-objects within a document.
  * @internal
@@ -979,13 +979,13 @@ import { FirebaseError as c } from "@firebase/util/dist/src/errors";
     q: any;
     /** Creates a new top-level parse context. */ ht(t: any, e: any, n: any, r?: boolean): Rn;
 }
-declare class xn extends bn {
+declare class Fn extends bn {
     constructor(t: any, e: any);
     lt: any;
     _toFieldTransform(t: any): be;
     isEqual(t: any): boolean;
 }
-declare class Fn extends bn {
+declare class xn extends bn {
     constructor(t: any, e: any);
     lt: any;
     _toFieldTransform(t: any): be;
@@ -1139,4 +1139,4 @@ declare class J {
     field: any;
     transform: any;
 }
-export { gn as Bytes, ln as CollectionReference, an as DocumentReference, Yn as DocumentSnapshot, yn as FieldPath, bn as FieldValue, rn as Firestore, U as FirestoreError, vn as GeoPoint, hn as Query, Zn as QueryConstraint, Hn as QueryDocumentSnapshot, Kn as QuerySnapshot, gt as Timestamp, Ur as Transaction, $r as WriteBatch, Ar as addDoc, Dr as arrayRemove, Vr as arrayUnion, fn as collection, dn as collectionGroup, un as connectFirestoreEmulator, Ir as deleteDoc, Rr as deleteField, wn as doc, _n as documentId, dr as endAt, fr as endBefore, br as getDoc, vr as getDocs, on as getFirestore, Nr as increment, sn as initializeFirestore, or as limit, ur as limitToLast, sr as orderBy, tr as query, pn as queryEqual, mn as refEqual, kr as runTransaction, Pr as serverTimestamp, Er as setDoc, w as setLogLevel, Jn as snapshotEqual, hr as startAfter, ar as startAt, cn as terminate, Tr as updateDoc, nr as where, Fr as writeBatch };
+export { gn as Bytes, ln as CollectionReference, an as DocumentReference, Yn as DocumentSnapshot, yn as FieldPath, bn as FieldValue, rn as Firestore, U as FirestoreError, vn as GeoPoint, hn as Query, Zn as QueryConstraint, Hn as QueryDocumentSnapshot, Kn as QuerySnapshot, gt as Timestamp, kr as Transaction, $r as WriteBatch, Ir as addDoc, Dr as arrayRemove, Vr as arrayUnion, fn as collection, dn as collectionGroup, un as connectFirestoreEmulator, Ar as deleteDoc, Rr as deleteField, wn as doc, _n as documentId, dr as endAt, fr as endBefore, br as getDoc, vr as getDocs, on as getFirestore, Nr as increment, sn as initializeFirestore, or as limit, ur as limitToLast, sr as orderBy, tr as query, pn as queryEqual, mn as refEqual, jr as runTransaction, Pr as serverTimestamp, Er as setDoc, w as setLogLevel, Jn as snapshotEqual, hr as startAfter, ar as startAt, cn as terminate, Tr as updateDoc, nr as where, xr as writeBatch };

package/dist/lite/packages/firestore/lite/index.d.ts

@@ -17,6 +17,7 @@ export { FieldValue } from '../src/lite-api/field_value';
 export { increment, arrayRemove, arrayUnion, serverTimestamp, deleteField } from '../src/lite-api/field_value_impl';
 export { FirestoreDataConverter, DocumentSnapshot, QueryDocumentSnapshot, QuerySnapshot, snapshotEqual } from '../src/lite-api/snapshot';
 export { WriteBatch, writeBatch } from '../src/lite-api/write_batch';
+export { TransactionOptions } from '../src/lite-api/transaction_options';
 export { Transaction, runTransaction } from '../src/lite-api/transaction';
 export { setLogLevel, LogLevelString as LogLevel } from '../src/util/log';
 export { Bytes } from '../src/lite-api/bytes';

package/dist/lite/packages/firestore/src/api/transaction.d.ts

@@ -19,6 +19,7 @@ import { DocumentReference } from '../lite-api/reference';
 import { Transaction as LiteTransaction } from '../lite-api/transaction';
 import { Firestore } from './database';
 import { DocumentSnapshot } from './snapshot';
+import { TransactionOptions } from './transaction_options';
 /**
  * A reference to a transaction.
  *
@@ -55,4 +56,4 @@ export declare class Transaction extends LiteTransaction {
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a
  * rejected promise with the corresponding failure error is returned.
  */
-export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>): Promise<T>;
+export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;

package/dist/lite/packages/firestore/src/api/transaction_options.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 { TransactionOptions } from '../lite-api/transaction_options';

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

@@ -22,6 +22,7 @@ export { DocumentChange, DocumentSnapshot, QueryDocumentSnapshot, QuerySnapshot,
 export { DocumentReference, CollectionReference, Query, doc, collection, collectionGroup, SetOptions, DocumentData, UpdateData, WithFieldValue, PartialWithFieldValue, refEqual, queryEqual } from './api/reference';
 export { endAt, endBefore, startAt, startAfter, limit, limitToLast, where, orderBy, query, QueryConstraint, QueryConstraintType, OrderByDirection, WhereFilterOp } from './api/filter';
 export { Unsubscribe, SnapshotListenOptions } from './api/reference_impl';
+export { TransactionOptions } from './api/transaction_options';
 export { runTransaction, Transaction } from './api/transaction';
 export { getDoc, getDocFromCache, getDocFromServer, getDocs, getDocsFromCache, getDocsFromServer, onSnapshot, onSnapshotsInSync, setDoc, updateDoc, deleteDoc, addDoc, executeWrite } from './api/reference_impl';
 export { FieldValue } from './api/field_value';

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

@@ -30,6 +30,7 @@ import { EventManager, ListenOptions, Observer } from './event_manager';
 import { Query } from './query';
 import { SyncEngine } from './sync_engine';
 import { Transaction } from './transaction';
+import { TransactionOptions } from './transaction_options';
 import { ViewSnapshot } from './view_snapshot';
 export declare const MAX_CONCURRENT_LIMBO_RESOLUTIONS = 100;
 /**
@@ -113,6 +114,6 @@ export declare function firestoreClientAddSnapshotsInSyncListener(client: Firest
  * been committed. For this reason, it is required that all reads are
  * performed before any writes. Transactions must be performed while online.
  */
-export declare function firestoreClientTransaction<T>(client: FirestoreClient, updateFunction: (transaction: Transaction) => Promise<T>): Promise<T>;
+export declare function firestoreClientTransaction<T>(client: FirestoreClient, updateFunction: (transaction: Transaction) => Promise<T>, options: TransactionOptions): Promise<T>;
 export declare function firestoreClientLoadBundle(client: FirestoreClient, databaseId: DatabaseId, data: ReadableStream<Uint8Array> | ArrayBuffer | string, resultTask: LoadBundleTask): void;
 export declare function firestoreClientGetNamedQuery(client: FirestoreClient, queryName: string): Promise<NamedQuery | undefined>;

package/dist/lite/packages/firestore/src/core/query.d.ts

@@ -76,9 +76,7 @@ export declare function asCollectionQueryAtPath(query: Query, path: ResourcePath
  * Returns true if this query does not specify any query constraints that
  * could remove results.
  */
-export declare function matchesAllDocuments(query: Query): boolean;
-export declare function hasLimitToFirst(query: Query): boolean;
-export declare function hasLimitToLast(query: Query): boolean;
+export declare function queryMatchesAllDocuments(query: Query): boolean;
 export declare function getFirstOrderByField(query: Query): FieldPath | null;
 export declare function getInequalityFilterField(query: Query): FieldPath | null;
 /**
@@ -113,7 +111,7 @@ export declare function queryOrderBy(query: Query): OrderBy[];
 export declare function queryToTarget(query: Query): Target;
 export declare function queryWithAddedFilter(query: Query, filter: Filter): Query;
 export declare function queryWithAddedOrderBy(query: Query, orderBy: OrderBy): Query;
-export declare function queryWithLimit(query: Query, limit: number, limitType: LimitType): Query;
+export declare function queryWithLimit(query: Query, limit: number | null, limitType: LimitType): Query;
 export declare function queryWithStartAt(query: Query, bound: Bound): Query;
 export declare function queryWithEndAt(query: Query, bound: Bound): Query;
 export declare function queryEquals(left: Query, right: Query): boolean;

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

@@ -72,16 +72,16 @@ export declare function targetGetArrayValues(target: Target, fieldIndex: FieldIn
 export declare function targetGetNotInValues(target: Target, fieldIndex: FieldIndex): ProtoValue[] | null;
 /**
  * Returns a lower bound of field values that can be used as a starting point to
- * scan the index defined by `fieldIndex`. Returns `null` if no lower bound
+ * scan the index defined by `fieldIndex`. Returns `MIN_VALUE` if no lower bound
  * exists.
  */
-export declare function targetGetLowerBound(target: Target, fieldIndex: FieldIndex): Bound | null;
+export declare function targetGetLowerBound(target: Target, fieldIndex: FieldIndex): Bound;
 /**
  * Returns an upper bound of field values that can be used as an ending point
- * when scanning the index defined by `fieldIndex`. Returns `null` if no
+ * when scanning the index defined by `fieldIndex`. Returns `MAX_VALUE` if no
  * upper bound exists.
  */
-export declare function targetGetUpperBound(target: Target, fieldIndex: FieldIndex): Bound | null;
+export declare function targetGetUpperBound(target: Target, fieldIndex: FieldIndex): Bound;
 /** Returns the number of segments of a perfect index for this target. */
 export declare function targetGetSegmentCount(target: Target): number;
 export declare abstract class Filter {

package/dist/lite/packages/firestore/src/core/transaction_options.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @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 declare const DEFAULT_TRANSACTION_OPTIONS: TransactionOptions;
+/**
+ * Options to customize transaction behavior.
+ */
+export declare interface TransactionOptions {
+    /** Maximum number of attempts to commit, after which transaction fails. Default is 5. */
+    readonly maxAttempts: number;
+}
+export declare function validateTransactionOptions(options: TransactionOptions): void;

package/dist/lite/packages/firestore/src/core/transaction_runner.d.ts

@@ -18,7 +18,7 @@ import { Datastore } from '../remote/datastore';
 import { AsyncQueue } from '../util/async_queue';
 import { Deferred } from '../util/promise';
 import { Transaction } from './transaction';
-export declare const DEFAULT_MAX_ATTEMPTS_COUNT = 5;
+import { TransactionOptions } from './transaction_options';
 /**
  * TransactionRunner encapsulates the logic needed to run and retry transactions
  * with backoff.
@@ -26,11 +26,12 @@ export declare const DEFAULT_MAX_ATTEMPTS_COUNT = 5;
 export declare class TransactionRunner<T> {
     private readonly asyncQueue;
     private readonly datastore;
+    private readonly options;
     private readonly updateFunction;
     private readonly deferred;
     private attemptsRemaining;
     private backoff;
-    constructor(asyncQueue: AsyncQueue, datastore: Datastore, updateFunction: (transaction: Transaction) => Promise<T>, deferred: Deferred<T>);
+    constructor(asyncQueue: AsyncQueue, datastore: Datastore, options: TransactionOptions, updateFunction: (transaction: Transaction) => Promise<T>, deferred: Deferred<T>);
     /** Runs the transaction and sets the result on deferred. */
     run(): void;
     private runWithBackOff;

package/dist/lite/packages/firestore/src/lite-api/transaction.d.ts

@@ -19,6 +19,7 @@ import { Firestore } from './database';
 import { FieldPath } from './field_path';
 import { DocumentReference, PartialWithFieldValue, SetOptions, UpdateData, WithFieldValue } from './reference';
 import { DocumentSnapshot } from './snapshot';
+import { TransactionOptions } from './transaction_options';
 /**
  * A reference to a transaction.
  *
@@ -116,4 +117,4 @@ export declare class Transaction {
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a
  * rejected promise with the corresponding failure error is returned.
  */
-export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>): Promise<T>;
+export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;

package/dist/lite/packages/firestore/src/lite-api/transaction_options.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @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.
+ */
+/**
+ * Options to customize transaction behavior.
+ */
+export declare interface TransactionOptions {
+    /** Maximum number of attempts to commit, after which transaction fails. Default is 5. */
+    readonly maxAttempts?: number;
+}

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

@@ -109,4 +109,9 @@ export interface IndexManager {
     updateCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, offset: IndexOffset): PersistencePromise<void>;
     /** Updates the index entries for the provided documents. */
     updateIndexEntries(transaction: PersistenceTransaction, documents: DocumentMap): PersistencePromise<void>;
+    /**
+     * Iterates over all field indexes that are used to serve the given target,
+     * and returns the minimum offset of them all.
+     */
+    getMinOffset(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexOffset>;
 }

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

@@ -70,11 +70,6 @@ export declare class IndexedDbIndexManager implements IndexManager {
     private generateLowerBound;
     /** Generates the upper bound for `arrayValue` and `directionalValue`. */
     private generateUpperBound;
-    /**
-     * Generates an empty bound that scopes the index scan to the current index
-     * and user.
-     */
-    private generateEmptyBound;
     private getFieldIndex;
     getIndexType(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexType>;
     /**
@@ -133,4 +128,5 @@ export declare class IndexedDbIndexManager implements IndexManager {
      * '[foo > 2 && foo != 3]` becomes  `[foo > 2 && < 3, foo > 3]`.
      */
     private createRange;
+    getMinOffset(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexOffset>;
 }

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

@@ -20,6 +20,7 @@ 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';
 import { DbTimestampKey } from './indexeddb_sentinels';
+export declare const INDEXING_ENABLED = false;
 export declare const INDEXING_SCHEMA_VERSION = 14;
 /**
  * Schema Version for the Web client:

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

@@ -33,7 +33,7 @@ import { RemoteDocumentCache } from './remote_document_cache';
 export declare class LocalDocumentsView {
     readonly remoteDocumentCache: RemoteDocumentCache;
     readonly mutationQueue: MutationQueue;
-    readonly indexManager: IndexManager;
+    private readonly indexManager;
     constructor(remoteDocumentCache: RemoteDocumentCache, mutationQueue: MutationQueue, indexManager: IndexManager);
     /**
      * Get the local view of the document identified by `key`.

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

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

package/dist/lite/packages/firestore/src/local/query_engine.d.ts

@@ -17,14 +17,35 @@
 import { Query } from '../core/query';
 import { SnapshotVersion } from '../core/snapshot_version';
 import { DocumentKeySet, DocumentMap } from '../model/collections';
+import { IndexManager } from './index_manager';
 import { LocalDocumentsView } from './local_documents_view';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
 /**
- * A query engine that takes advantage of the target document mapping in the
- * QueryCache. Query execution is optimized by only reading the documents that
- * previously matched a query plus any documents that were edited after the
- * query was last listened to.
+ * The Firestore query engine.
+ *
+ * Firestore queries can be executed in three modes. The Query Engine determines
+ * what mode to use based on what data is persisted. The mode only determines
+ * the runtime complexity of the query - the result set is equivalent across all
+ * implementations.
+ *
+ * The Query engine will use indexed-based execution if a user has configured
+ * any index that can be used to execute query (via `setIndexConfiguration()`).
+ * Otherwise, the engine will try to optimize the query by re-using a previously
+ * persisted query result. If that is not possible, the query will be executed
+ * via a full collection scan.
+ *
+ * Index-based execution is the default when available. The query engine
+ * supports partial indexed execution and merges the result from the index
+ * lookup with documents that have not yet been indexed. The index evaluation
+ * matches the backend's format and as such, the SDK can use indexing for all
+ * queries that the backend supports.
+ *
+ * If no index exists, the query engine tries to take advantage of the target
+ * document mapping in the TargetCache. These mappings exists for all queries
+ * that have been synced with the backend at least once and allow the query
+ * engine to only read documents that previously matched a query plus any
+ * documents that were edited after the query was last listened to.
  *
  * There are some cases when this optimization is not guaranteed to produce
  * the same results as full collection scans. In these cases, query
@@ -40,16 +61,29 @@ import { PersistenceTransaction } from './persistence_transaction';
  */
 export declare class QueryEngine {
     private localDocumentsView;
+    private indexManager;
+    private initialized;
     /** Sets the document view to query against. */
-    setLocalDocumentsView(localDocuments: LocalDocumentsView): void;
+    initialize(localDocuments: LocalDocumentsView, indexManager: IndexManager): void;
     /** Returns all local documents matching the specified query. */
     getDocumentsMatchingQuery(transaction: PersistenceTransaction, query: Query, lastLimboFreeSnapshotVersion: SnapshotVersion, remoteKeys: DocumentKeySet): PersistencePromise<DocumentMap>;
+    /**
+     * Performs an indexed query that evaluates the query based on a collection's
+     * persisted index values. Returns `null` if an index is not available.
+     */
+    private performQueryUsingIndex;
+    /**
+     * Performs a query based on the target's persisted query mapping. Returns
+     * `null` if the mapping is not available or cannot be used.
+     */
+    private performQueryUsingRemoteKeys;
     /** Applies the query filter and sorting to the provided documents.  */
     private applyQuery;
     /**
      * Determines if a limit query needs to be refilled from cache, making it
      * ineligible for index-free execution.
      *
+     * @param query The query.
      * @param sortedPreviousResults - The documents that matched the query when it
      * was last synchronized, sorted by the query's comparator.
      * @param remoteKeys - The document keys that matched the query at the last
@@ -59,4 +93,9 @@ export declare class QueryEngine {
      */
     private needsRefill;
     private executeFullCollectionScan;
+    /**
+     * Combines the results from an indexed execution with the remaining documents
+     * that have not yet been indexed.
+     */
+    private appendRemainingResults;
 }

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

@@ -31,7 +31,7 @@ export interface DocumentSizeEntries {
     sizeMap: SortedMap<DocumentKey, number>;
 }
 export declare type DocumentMap = SortedMap<DocumentKey, Document>;
-export declare function documentMap(): DocumentMap;
+export declare function documentMap(...docs: Document[]): DocumentMap;
 export declare type OverlayMap = ObjectMap<DocumentKey, Overlay>;
 export declare function newOverlayMap(): OverlayMap;
 export declare type MutationMap = ObjectMap<DocumentKey, Mutation>;

package/dist/lite/packages/firestore/src/model/values.d.ts

@@ -81,5 +81,17 @@ export declare function isMaxValue(value: Value): boolean;
 export declare function valuesGetLowerBound(value: Value): Value;
 /** Returns the largest value for the given value type (exclusive). */
 export declare function valuesGetUpperBound(value: Value): Value;
-export declare function valuesMax(left: Value | undefined, right: Value | undefined): Value | undefined;
-export declare function valuesMin(left: Value | undefined, right: Value | undefined): Value | undefined;
+export declare function lowerBoundCompare(left: {
+    value: Value;
+    inclusive: boolean;
+}, right: {
+    value: Value;
+    inclusive: boolean;
+}): number;
+export declare function upperBoundCompare(left: {
+    value: Value;
+    inclusive: boolean;
+}, right: {
+    value: Value;
+    inclusive: boolean;
+}): number;

package/dist/lite/packages/firestore/src/util/misc.d.ts

@@ -25,6 +25,9 @@ export declare function primitiveComparator<T>(left: T, right: T): number;
 export interface Equatable<T> {
     isEqual(other: T): boolean;
 }
+export interface Iterable<V> {
+    forEach: (cb: (v: V) => void) => void;
+}
 /** Helper to compare arrays using isEqual(). */
 export declare function arrayEquals<T>(left: T[], right: T[], comparator: (l: T, r: T) => boolean): boolean;
 /**

package/dist/lite/packages/firestore/test/unit/local/counting_query_engine.d.ts

@@ -16,6 +16,7 @@
  */
 import { Query } from '../../../src/core/query';
 import { SnapshotVersion } from '../../../src/core/snapshot_version';
+import { IndexManager } from '../../../src/local/index_manager';
 import { LocalDocumentsView } from '../../../src/local/local_documents_view';
 import { PersistencePromise } from '../../../src/local/persistence_promise';
 import { PersistenceTransaction } from '../../../src/local/persistence_transaction';
@@ -51,7 +52,7 @@ export declare class CountingQueryEngine extends QueryEngine {
     documentsReadByKey: number;
     resetCounts(): void;
     getDocumentsMatchingQuery(transaction: PersistenceTransaction, query: Query, lastLimboFreeSnapshotVersion: SnapshotVersion, remoteKeys: DocumentKeySet): PersistencePromise<DocumentMap>;
-    setLocalDocumentsView(localDocuments: LocalDocumentsView): void;
+    initialize(localDocuments: LocalDocumentsView, indexManager: IndexManager): void;
     private wrapRemoteDocumentCache;
     private wrapMutationQueue;
 }

package/dist/lite/private.d.ts

@@ -1970,7 +1970,7 @@ export declare function refEqual<T>(left: DocumentReference<T> | CollectionRefer
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a
  * rejected promise with the corresponding failure error is returned.
  */
-export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>): Promise<T>;
+export declare function runTransaction<T>(firestore: Firestore, updateFunction: (transaction: Transaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
 
 /**
  * Returns a sentinel used with {@link @firebase/firestore/lite#(setDoc:1)} or {@link @firebase/firestore/lite#(updateDoc:1)} to
@@ -2475,6 +2475,30 @@ declare class Transaction_2 {
     private ensureCommitNotCalled;
 }
 
+/**
+ * @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.
+ */
+/**
+ * Options to customize transaction behavior.
+ */
+export declare interface TransactionOptions {
+    /** Maximum number of attempts to commit, after which transaction fails. Default is 5. */
+    readonly maxAttempts?: number;
+}
+
 /** Used to represent a field transform on a mutation. */
 declare class TransformOperation {
     private _;