@firebase/firestore 3.7.3 → 3.8.0-canary.20e5ef7fb

package/dist/internal.d.ts

@@ -127,10 +127,34 @@ export declare type AggregateSpecData<T extends AggregateSpec> = {
     [P in keyof T]: T[P] extends AggregateField<infer U> ? U : never;
 };
 
+/**
+ * Creates a {@link QueryCompositeFilterConstraint} that performs a logical AND
+ * of all the provided {@link QueryFilterConstraint}s.
+ *
+ * @param queryConstraints - Optional. The {@link QueryFilterConstraint}s
+ * for AND operation. These must be created with calls to {@link where},
+ * {@link or}, or {@link and}.
+ * @returns The created {@link QueryCompositeFilterConstraint}.
+ * @internal TODO remove this internal tag with OR Query support in the server
+ */
+export declare function and(...queryConstraints: QueryFilterConstraint[]): QueryCompositeFilterConstraint;
+
 declare interface ApiClientObjectMap<T> {
     [k: string]: T;
 }
 
+/**
+ * An `AppliableConstraint` is an abstraction of a constraint that can be applied
+ * to a Firestore query.
+ */
+declare abstract class AppliableConstraint {
+    /**
+     * Takes the provided {@link Query} and returns a copy of the {@link Query} with this
+     * {@link AppliableConstraint} applied.
+     */
+    abstract _apply<T>(query: Query<T>): Query<T>;
+}
+
 /**
  * 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
@@ -636,7 +660,12 @@ declare interface ComponentConfiguration {
     maxConcurrentLimboResolutions: number;
 }
 
-declare type CompositeFilterOp = 'OPERATOR_UNSPECIFIED' | 'AND';
+declare type CompositeFilterOp = 'OPERATOR_UNSPECIFIED' | 'AND' | 'OR';
+
+declare const enum CompositeOperator {
+    OR = "or",
+    AND = "and"
+}
 
 /**
  * Modify this instance to communicate with the Cloud Firestore emulator.
@@ -920,6 +949,12 @@ declare interface Document_2 {
      * `SnapshotVersion.min()` for documents created by the user.
      */
     readonly readTime: SnapshotVersion;
+    /**
+     * The timestamp at which the document was created. This value increases
+     * monotonically when a document is deleted then recreated. It can also be
+     * compared to `createTime` of other documents and the `readTime` of a query.
+     */
+    readonly createTime: SnapshotVersion;
     /** The underlying data of this document or an empty value if no data exists. */
     readonly data: ObjectValue;
     /** Returns whether local mutations were applied via the mutation queue. */
@@ -1383,48 +1418,48 @@ export declare function enableMultiTabIndexedDbPersistence(firestore: Firestore)
 export declare function enableNetwork(firestore: Firestore): Promise<void>;
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to end at the
- * provided document (inclusive). The end position is relative to the order of
- * the query. The document must contain all of the fields provided in the
+ * Creates a {@link QueryEndAtConstraint} that modifies the result set to end at
+ * the provided document (inclusive). The end position is relative to the order
+ * of the query. The document must contain all of the fields provided in the
  * orderBy of the query.
  *
  * @param snapshot - The snapshot of the document to end at.
- * @returns A {@link QueryConstraint} to pass to `query()`
+ * @returns A {@link QueryEndAtConstraint} to pass to `query()`
  */
-export declare function endAt(snapshot: DocumentSnapshot_2<unknown>): QueryConstraint;
+export declare function endAt(snapshot: DocumentSnapshot_2<unknown>): QueryEndAtConstraint;
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to end at the
- * provided fields relative to the order of the query. The order of the field
+ * Creates a {@link QueryEndAtConstraint} that modifies the result set to end at
+ * the provided fields relative to the order of the query. The order of the field
  * values must match the order of the order by clauses of the query.
  *
  * @param fieldValues - The field values to end this query at, in order
  * of the query's order by.
- * @returns A {@link QueryConstraint} to pass to `query()`
+ * @returns A {@link QueryEndAtConstraint} to pass to `query()`
  */
-export declare function endAt(...fieldValues: unknown[]): QueryConstraint;
+export declare function endAt(...fieldValues: unknown[]): QueryEndAtConstraint;
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to end before the
- * provided document (exclusive). The end position is relative to the order of
- * the query. The document must contain all of the fields provided in the
- * orderBy of the query.
+ * Creates a {@link QueryEndAtConstraint} that modifies the result set to end
+ * before the provided document (exclusive). The end position is relative to the
+ * order of the query. The document must contain all of the fields provided in
+ * the orderBy of the query.
  *
  * @param snapshot - The snapshot of the document to end before.
- * @returns A {@link QueryConstraint} to pass to `query()`
+ * @returns A {@link QueryEndAtConstraint} to pass to `query()`
  */
-export declare function endBefore(snapshot: DocumentSnapshot_2<unknown>): QueryConstraint;
+export declare function endBefore(snapshot: DocumentSnapshot_2<unknown>): QueryEndAtConstraint;
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to end before the
- * provided fields relative to the order of the query. The order of the field
- * values must match the order of the order by clauses of the query.
+ * Creates a {@link QueryEndAtConstraint} that modifies the result set to end
+ * before the provided fields relative to the order of the query. The order of
+ * the field values must match the order of the order by clauses of the query.
  *
  * @param fieldValues - The field values to end this query before, in order
  * of the query's order by.
- * @returns A {@link QueryConstraint} to pass to `query()`
+ * @returns A {@link QueryEndAtConstraint} to pass to `query()`
  */
-export declare function endBefore(...fieldValues: unknown[]): QueryConstraint;
+export declare function endBefore(...fieldValues: unknown[]): QueryEndAtConstraint;
 
 /**
  * @internal
@@ -1456,6 +1491,24 @@ declare interface EventManager {
  */
 export declare function executeWrite(firestore: Firestore, mutations: Mutation[]): Promise<void>;
 
+declare class FieldFilter extends Filter {
+    readonly field: _FieldPath;
+    readonly op: Operator;
+    readonly value: Value;
+    protected constructor(field: _FieldPath, op: Operator, value: Value);
+    /**
+     * Creates a filter based on the provided arguments.
+     */
+    static create(field: _FieldPath, op: Operator, value: Value): FieldFilter;
+    private static createKeyFieldInFilter;
+    matches(doc: Document_2): boolean;
+    protected matchesComparison(comparison: number): boolean;
+    isInequality(): boolean;
+    getFlattenedFilters(): readonly FieldFilter[];
+    getFilters(): Filter[];
+    getFirstInequalityField(): _FieldPath | null;
+}
+
 declare type FieldFilterOp = 'OPERATOR_UNSPECIFIED' | 'LESS_THAN' | 'LESS_THAN_OR_EQUAL' | 'GREATER_THAN' | 'GREATER_THAN_OR_EQUAL' | 'EQUAL' | 'NOT_EQUAL' | 'ARRAY_CONTAINS' | 'IN' | 'ARRAY_CONTAINS_ANY' | 'NOT_IN';
 
 /**
@@ -1615,6 +1668,9 @@ export declare abstract class FieldValue {
 
 declare abstract class Filter {
     abstract matches(doc: Document_2): boolean;
+    abstract getFlattenedFilters(): readonly FieldFilter[];
+    abstract getFilters(): Filter[];
+    abstract getFirstInequalityField(): _FieldPath | null;
 }
 
 /**
@@ -2484,7 +2540,8 @@ export declare function getDocs<T>(query: Query<T>): Promise<QuerySnapshot<T>>;
 
 /**
  * Executes the query and returns the results as a `QuerySnapshot` from cache.
- * Returns an error if the document is not currently cached.
+ * Returns an empty result set if no documents matching the query are currently
+ * cached.
  *
  * @returns A `Promise` that will be resolved with the results of the query.
  */
@@ -2817,23 +2874,25 @@ export declare function initializeFirestore(app: FirebaseApp, settings: Firestor
 export declare function _isBase64Available(): boolean;
 
 /**
- * Creates a {@link QueryConstraint} that only returns the first matching documents.
+ * Creates a {@link QueryLimitConstraint} that only returns the first matching
+ * documents.
  *
  * @param limit - The maximum number of items to return.
- * @returns The created {@link Query}.
+ * @returns The created {@link QueryLimitConstraint}.
  */
-export declare function limit(limit: number): QueryConstraint;
+export declare function limit(limit: number): QueryLimitConstraint;
 
 /**
- * Creates a {@link QueryConstraint} that only returns the last matching documents.
+ * Creates a {@link QueryLimitConstraint} that only returns the last matching
+ * documents.
  *
  * You must specify at least one `orderBy` clause for `limitToLast` queries,
  * otherwise an exception will be thrown during execution.
  *
  * @param limit - The maximum number of items to return.
- * @returns The created {@link Query}.
+ * @returns The created {@link QueryLimitConstraint}.
  */
-export declare function limitToLast(limit: number): QueryConstraint;
+export declare function limitToLast(limit: number): QueryLimitConstraint;
 
 declare const enum LimitType {
     First = "F",
@@ -3076,8 +3135,6 @@ declare class LocalDocumentsView {
     private getDocumentsMatchingDocumentQuery;
     private getDocumentsMatchingCollectionGroupQuery;
     private getDocumentsMatchingCollectionQuery;
-    /** Returns a base document that can be used to apply `overlay`. */
-    private getBaseDocument;
 }
 
 declare interface LocalStore {
@@ -3165,6 +3222,7 @@ declare class MutableDocument implements Document_2 {
     private documentType;
     version: SnapshotVersion;
     readTime: SnapshotVersion;
+    createTime: SnapshotVersion;
     data: ObjectValue;
     private documentState;
     private constructor();
@@ -3177,7 +3235,7 @@ declare class MutableDocument implements Document_2 {
      * Creates a new document that is known to exist with the given data at the
      * given version.
      */
-    static newFoundDocument(documentKey: _DocumentKey, version: SnapshotVersion, value: ObjectValue): MutableDocument;
+    static newFoundDocument(documentKey: _DocumentKey, version: SnapshotVersion, createTime: SnapshotVersion, value: ObjectValue): MutableDocument;
     /** Creates a new document that is known to not exist at the given version. */
     static newNoDocument(documentKey: _DocumentKey, version: SnapshotVersion): MutableDocument;
     /**
@@ -3911,6 +3969,31 @@ export declare function onSnapshotsInSync(firestore: Firestore, observer: {
  */
 export declare function onSnapshotsInSync(firestore: Firestore, onSync: () => void): Unsubscribe;
 
+declare const enum Operator {
+    LESS_THAN = "<",
+    LESS_THAN_OR_EQUAL = "<=",
+    EQUAL = "==",
+    NOT_EQUAL = "!=",
+    GREATER_THAN = ">",
+    GREATER_THAN_OR_EQUAL = ">=",
+    ARRAY_CONTAINS = "array-contains",
+    IN = "in",
+    NOT_IN = "not-in",
+    ARRAY_CONTAINS_ANY = "array-contains-any"
+}
+
+/**
+ * Creates a {@link QueryCompositeFilterConstraint} that performs a logical OR
+ * of all the provided {@link QueryFilterConstraint}s.
+ *
+ * @param queryConstraints - Optional. The {@link QueryFilterConstraint}s
+ * for OR operation. These must be created with calls to {@link where},
+ * {@link or}, or {@link and}.
+ * @returns The created {@link QueryCompositeFilterConstraint}.
+ * @internal TODO remove this internal tag with OR Query support in the server
+ */
+export declare function or(...queryConstraints: QueryFilterConstraint[]): QueryCompositeFilterConstraint;
+
 /**
  * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
  */
@@ -3921,15 +4004,18 @@ declare class OrderBy {
 }
 
 /**
- * Creates a {@link QueryConstraint} that sorts the query result by the
+ * Creates a {@link QueryOrderByConstraint} that sorts the query result by the
  * specified field, optionally in descending order instead of ascending.
  *
+ * Note: Documents that do not contain the specified field will not be present
+ * in the query result.
+ *
  * @param fieldPath - The field to sort by.
  * @param directionStr - Optional direction to sort by ('asc' or 'desc'). If
  * not specified, order will be ascending.
- * @returns The created {@link Query}.
+ * @returns The created {@link QueryOrderByConstraint}.
  */
-export declare function orderBy(fieldPath: string | FieldPath, directionStr?: OrderByDirection): QueryConstraint;
+export declare function orderBy(fieldPath: string | FieldPath, directionStr?: OrderByDirection): QueryOrderByConstraint;
 
 /**
  * The direction of a {@link orderBy} clause is specified as 'desc' or 'asc'
@@ -4324,10 +4410,28 @@ export declare class Query<T = DocumentData> {
 }
 
 /**
- * Creates a new immutable instance of {@link Query} that is extended to also include
- * additional query constraints.
+ * Creates a new immutable instance of {@link Query} that is extended to also
+ * include additional query constraints.
  *
- * @param query - The {@link Query} instance to use as a base for the new constraints.
+ * @param query - The {@link Query} instance to use as a base for the new
+ * constraints.
+ * @param compositeFilter - The {@link QueryCompositeFilterConstraint} to
+ * apply. Create {@link QueryCompositeFilterConstraint} using {@link and} or
+ * {@link or}.
+ * @param queryConstraints - Additional {@link QueryNonFilterConstraint}s to
+ * apply (e.g. {@link orderBy}, {@link limit}).
+ * @throws if any of the provided query constraints cannot be combined with the
+ * existing or new constraints.
+ * @internal TODO remove this internal tag with OR Query support in the server
+ */
+export declare function query<T>(query: Query<T>, compositeFilter: QueryCompositeFilterConstraint, ...queryConstraints: QueryNonFilterConstraint[]): Query<T>;
+
+/**
+ * Creates a new immutable instance of {@link Query} that is extended to also
+ * include additional query constraints.
+ *
+ * @param query - The {@link Query} instance to use as a base for the new
+ * constraints.
  * @param queryConstraints - The list of {@link QueryConstraint}s to apply.
  * @throws if any of the provided query constraints cannot be combined with the
  * existing or new constraints.
@@ -4351,20 +4455,46 @@ declare interface Query_2 {
     readonly endAt: Bound | null;
 }
 
+/**
+ * A `QueryCompositeFilterConstraint` is used to narrow the set of documents
+ * returned by a Firestore query by performing the logical OR or AND of multiple
+ * {@link QueryFieldFilterConstraint}s or {@link QueryCompositeFilterConstraint}s.
+ * `QueryCompositeFilterConstraint`s are created by invoking {@link or} or
+ * {@link and} and can then be passed to {@link query} to create a new query
+ * instance that also contains the `QueryCompositeFilterConstraint`.
+ * @internal TODO remove this internal tag with OR Query support in the server
+ */
+export declare class QueryCompositeFilterConstraint extends AppliableConstraint {
+    /** The type of this query constraint */
+    readonly type: 'or' | 'and';
+    private readonly _queryConstraints;
+    /**
+     * @internal
+     */
+    protected constructor(
+    /** The type of this query constraint */
+    type: 'or' | 'and', _queryConstraints: QueryFilterConstraint[]);
+    static _create(type: 'or' | 'and', _queryConstraints: QueryFilterConstraint[]): QueryCompositeFilterConstraint;
+    _parse<T>(query: Query<T>): Filter;
+    _apply<T>(query: Query<T>): Query<T>;
+    _getQueryConstraints(): readonly AppliableConstraint[];
+    _getOperator(): CompositeOperator;
+}
+
 /**
  * A `QueryConstraint` is used to narrow the set of documents returned by a
  * Firestore query. `QueryConstraint`s are created by invoking {@link where},
- * {@link orderBy}, {@link (startAt:1)}, {@link (startAfter:1)}, {@link
- * endBefore:1}, {@link (endAt:1)}, {@link limit} or {@link limitToLast} and
+ * {@link orderBy}, {@link startAt}, {@link startAfter}, {@link
+ * endBefore}, {@link endAt}, {@link limit}, {@link limitToLast} and
  * can then be passed to {@link query} to create a new query instance that
  * also contains this `QueryConstraint`.
  */
-export declare abstract class QueryConstraint {
-    /** The type of this query constraints */
+export declare abstract class QueryConstraint extends AppliableConstraint {
+    /** The type of this query constraint */
     abstract readonly type: QueryConstraintType;
     /**
      * Takes the provided {@link Query} and returns a copy of the {@link Query} with this
-     * {@link QueryConstraint} applied.
+     * {@link AppliableConstraint} applied.
      */
     abstract _apply<T>(query: Query<T>): Query<T>;
 }
@@ -4421,6 +4551,28 @@ declare class QueryDocumentSnapshot_2<T = DocumentData> extends DocumentSnapshot
     data(): T;
 }
 
+/**
+ * A `QueryEndAtConstraint` is used to exclude documents from the end of a
+ * result set returned by a Firestore query.
+ * `QueryEndAtConstraint`s are created by invoking {@link (endAt:1)} or
+ * {@link (endBefore:1)} and can then be passed to {@link query} to create a new
+ * query instance that also contains this `QueryEndAtConstraint`.
+ */
+export declare class QueryEndAtConstraint extends QueryConstraint {
+    /** The type of this query constraint */
+    readonly type: 'endBefore' | 'endAt';
+    private readonly _docOrFields;
+    private readonly _inclusive;
+    /**
+     * @internal
+     */
+    protected constructor(
+    /** The type of this query constraint */
+    type: 'endBefore' | 'endAt', _docOrFields: Array<unknown | DocumentSnapshot_2<unknown>>, _inclusive: boolean);
+    static _create(type: 'endBefore' | 'endAt', _docOrFields: Array<unknown | DocumentSnapshot_2<unknown>>, _inclusive: boolean): QueryEndAtConstraint;
+    _apply<T>(query: Query<T>): Query<T>;
+}
+
 /**
  * Returns true if the provided queries point to the same collection and apply
  * the same constraints.
@@ -4432,6 +4584,93 @@ declare class QueryDocumentSnapshot_2<T = DocumentData> extends DocumentSnapshot
  */
 export declare function queryEqual<T>(left: Query<T>, right: Query<T>): boolean;
 
+/**
+ * A `QueryFieldFilterConstraint` is used to narrow the set of documents returned by
+ * a Firestore query by filtering on one or more document fields.
+ * `QueryFieldFilterConstraint`s are created by invoking {@link where} and can then
+ * be passed to {@link query} to create a new query instance that also contains
+ * this `QueryFieldFilterConstraint`.
+ */
+export declare class QueryFieldFilterConstraint extends QueryConstraint {
+    private readonly _field;
+    private _op;
+    private _value;
+    /** The type of this query constraint */
+    readonly type = "where";
+    /**
+     * @internal
+     */
+    protected constructor(_field: _FieldPath, _op: Operator, _value: unknown);
+    static _create(_field: _FieldPath, _op: Operator, _value: unknown): QueryFieldFilterConstraint;
+    _apply<T>(query: Query<T>): Query<T>;
+    _parse<T>(query: Query<T>): FieldFilter;
+}
+
+/**
+ * `QueryFilterConstraint` is a helper union type that represents
+ * {@link QueryFieldFilterConstraint} and {@link QueryCompositeFilterConstraint}.
+ * `QueryFilterConstraint`s are created by invoking {@link or} or {@link and}
+ * and can then be passed to {@link query} to create a new query instance that
+ * also contains the `QueryConstraint`.
+ * @internal TODO remove this internal tag with OR Query support in the server
+ */
+export declare type QueryFilterConstraint = QueryFieldFilterConstraint | QueryCompositeFilterConstraint;
+
+/**
+ * A `QueryLimitConstraint` is used to limit the number of documents returned by
+ * a Firestore query.
+ * `QueryLimitConstraint`s are created by invoking {@link limit} or
+ * {@link limitToLast} and can then be passed to {@link query} to create a new
+ * query instance that also contains this `QueryLimitConstraint`.
+ */
+export declare class QueryLimitConstraint extends QueryConstraint {
+    /** The type of this query constraint */
+    readonly type: 'limit' | 'limitToLast';
+    private readonly _limit;
+    private readonly _limitType;
+    /**
+     * @internal
+     */
+    protected constructor(
+    /** The type of this query constraint */
+    type: 'limit' | 'limitToLast', _limit: number, _limitType: LimitType);
+    static _create(type: 'limit' | 'limitToLast', _limit: number, _limitType: LimitType): QueryLimitConstraint;
+    _apply<T>(query: Query<T>): Query<T>;
+}
+
+/**
+ * `QueryNonFilterConstraint` is a helper union type that represents
+ * QueryConstraints which are used to narrow or order the set of documents,
+ * but that do not explicitly filter on a document field.
+ * `QueryNonFilterConstraint`s are created by invoking {@link orderBy},
+ * {@link startAt}, {@link startAfter}, {@link endBefore}, {@link endAt},
+ * {@link limit} or {@link limitToLast} and can then be passed to {@link query}
+ * to create a new query instance that also contains the `QueryConstraint`.
+ */
+export declare type QueryNonFilterConstraint = QueryOrderByConstraint | QueryLimitConstraint | QueryStartAtConstraint | QueryEndAtConstraint;
+
+/**
+ * A `QueryOrderByConstraint` is used to sort the set of documents returned by a
+ * Firestore query. `QueryOrderByConstraint`s are created by invoking
+ * {@link orderBy} and can then be passed to {@link query} to create a new query
+ * instance that also contains this `QueryOrderByConstraint`.
+ *
+ * Note: Documents that do not contain the orderBy field will not be present in
+ * the query result.
+ */
+export declare class QueryOrderByConstraint extends QueryConstraint {
+    private readonly _field;
+    private _direction;
+    /** The type of this query constraint */
+    readonly type = "orderBy";
+    /**
+     * @internal
+     */
+    protected constructor(_field: _FieldPath, _direction: Direction);
+    static _create(_field: _FieldPath, _direction: Direction): QueryOrderByConstraint;
+    _apply<T>(query: Query<T>): Query<T>;
+}
+
 /**
  * A `QuerySnapshot` contains zero or more `DocumentSnapshot` objects
  * representing the results of a query. The documents can be accessed as an
@@ -4483,6 +4722,28 @@ export declare class QuerySnapshot<T = DocumentData> {
     docChanges(options?: SnapshotListenOptions): Array<DocumentChange<T>>;
 }
 
+/**
+ * A `QueryStartAtConstraint` is used to exclude documents from the start of a
+ * result set returned by a Firestore query.
+ * `QueryStartAtConstraint`s are created by invoking {@link (startAt:1)} or
+ * {@link (startAfter:1)} and can then be passed to {@link query} to create a
+ * new query instance that also contains this `QueryStartAtConstraint`.
+ */
+export declare class QueryStartAtConstraint extends QueryConstraint {
+    /** The type of this query constraint */
+    readonly type: 'startAt' | 'startAfter';
+    private readonly _docOrFields;
+    private readonly _inclusive;
+    /**
+     * @internal
+     */
+    protected constructor(
+    /** The type of this query constraint */
+    type: 'startAt' | 'startAfter', _docOrFields: Array<unknown | DocumentSnapshot_2<unknown>>, _inclusive: boolean);
+    static _create(type: 'startAt' | 'startAfter', _docOrFields: Array<unknown | DocumentSnapshot_2<unknown>>, _inclusive: boolean): QueryStartAtConstraint;
+    _apply<T>(query: Query<T>): Query<T>;
+}
+
 /** The different states of a watch target. */
 declare type QueryTargetState = 'not-current' | 'current' | 'rejected';
 
@@ -5234,48 +5495,48 @@ declare class SortedSetIterator<T> {
 }
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to start after the
- * provided document (exclusive). The starting position is relative to the order
- * of the query. The document must contain all of the fields provided in the
- * orderBy of the query.
+ * Creates a {@link QueryStartAtConstraint} that modifies the result set to
+ * start after the provided document (exclusive). The starting position is
+ * relative to the order of the query. The document must contain all of the
+ * fields provided in the orderBy of the query.
  *
  * @param snapshot - The snapshot of the document to start after.
- * @returns A {@link QueryConstraint} to pass to `query()`
+ * @returns A {@link QueryStartAtConstraint} to pass to `query()`
  */
-export declare function startAfter(snapshot: DocumentSnapshot_2<unknown>): QueryConstraint;
+export declare function startAfter(snapshot: DocumentSnapshot_2<unknown>): QueryStartAtConstraint;
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to start after the
- * provided fields relative to the order of the query. The order of the field
- * values must match the order of the order by clauses of the query.
+ * Creates a {@link QueryStartAtConstraint} that modifies the result set to
+ * start after the provided fields relative to the order of the query. The order
+ * of the field values must match the order of the order by clauses of the query.
  *
  * @param fieldValues - The field values to start this query after, in order
  * of the query's order by.
- * @returns A {@link QueryConstraint} to pass to `query()`
+ * @returns A {@link QueryStartAtConstraint} to pass to `query()`
  */
-export declare function startAfter(...fieldValues: unknown[]): QueryConstraint;
+export declare function startAfter(...fieldValues: unknown[]): QueryStartAtConstraint;
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to start at the
- * provided document (inclusive). The starting position is relative to the order
- * of the query. The document must contain all of the fields provided in the
- * `orderBy` of this query.
+ * Creates a {@link QueryStartAtConstraint} that modifies the result set to
+ * start at the provided document (inclusive). The starting position is relative
+ * to the order of the query. The document must contain all of the fields
+ * provided in the `orderBy` of this query.
  *
  * @param snapshot - The snapshot of the document to start at.
- * @returns A {@link QueryConstraint} to pass to `query()`.
+ * @returns A {@link QueryStartAtConstraint} to pass to `query()`.
  */
-export declare function startAt(snapshot: DocumentSnapshot_2<unknown>): QueryConstraint;
+export declare function startAt(snapshot: DocumentSnapshot_2<unknown>): QueryStartAtConstraint;
 
 /**
- * Creates a {@link QueryConstraint} that modifies the result set to start at the
- * provided fields relative to the order of the query. The order of the field
- * values must match the order of the order by clauses of the query.
+ * Creates a {@link QueryStartAtConstraint} that modifies the result set to
+ * start at the provided fields relative to the order of the query. The order of
+ * the field values must match the order of the order by clauses of the query.
  *
  * @param fieldValues - The field values to start this query at, in order
  * of the query's order by.
- * @returns A {@link QueryConstraint} to pass to `query()`.
+ * @returns A {@link QueryStartAtConstraint} to pass to `query()`.
  */
-export declare function startAt(...fieldValues: unknown[]): QueryConstraint;
+export declare function startAt(...fieldValues: unknown[]): QueryStartAtConstraint;
 
 declare type StructuredQuery = firestoreV1ApiClientInterfaces.StructuredQuery;
 
@@ -6161,17 +6422,17 @@ declare class ViewSnapshot {
 export declare function waitForPendingWrites(firestore: Firestore): Promise<void>;
 
 /**
- * Creates a {@link QueryConstraint} that enforces that documents must contain the
- * specified field and that the value should satisfy the relation constraint
- * provided.
+ * Creates a {@link QueryFieldFilterConstraint} that enforces that documents
+ * must contain the specified field and that the value should satisfy the
+ * relation constraint provided.
  *
  * @param fieldPath - The path to compare
  * @param opStr - The operation string (e.g "&lt;", "&lt;=", "==", "&lt;",
  *   "&lt;=", "!=").
  * @param value - The value for comparison
- * @returns The created {@link Query}.
+ * @returns The created {@link QueryFieldFilterConstraint}.
  */
-export declare function where(fieldPath: string | FieldPath, opStr: WhereFilterOp, value: unknown): QueryConstraint;
+export declare function where(fieldPath: string | FieldPath, opStr: WhereFilterOp, value: unknown): QueryFieldFilterConstraint;
 
 /**
  * Filter conditions in a {@link where} clause are specified using the

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

@@ -11,7 +11,7 @@ export { AggregateField, AggregateFieldType, AggregateSpec, AggregateSpecData, A
 export { FirestoreSettings as Settings } from '../src/lite-api/settings';
 export { Firestore as Firestore, EmulatorMockTokenOptions, initializeFirestore, getFirestore, terminate, connectFirestoreEmulator } from '../src/lite-api/database';
 export { DocumentData, UpdateData, WithFieldValue, PartialWithFieldValue, SetOptions, DocumentReference, Query, CollectionReference, collection, collectionGroup, doc, refEqual, queryEqual } from '../src/lite-api/reference';
-export { endAt, endBefore, startAt, startAfter, limit, limitToLast, orderBy, OrderByDirection, where, WhereFilterOp, query, QueryConstraint, QueryConstraintType } from '../src/lite-api/query';
+export { and, endAt, endBefore, startAt, startAfter, limit, limitToLast, where, or, orderBy, query, QueryConstraint, QueryConstraintType, QueryCompositeFilterConstraint, QueryFilterConstraint, QueryFieldFilterConstraint, QueryOrderByConstraint, QueryLimitConstraint, QueryNonFilterConstraint, QueryStartAtConstraint, QueryEndAtConstraint, OrderByDirection, WhereFilterOp } from '../src/lite-api/query';
 export { addDoc, deleteDoc, updateDoc, setDoc, getDoc, getDocs } from '../src/lite-api/reference_impl';
 export { Primitive, NestedUpdateFields, ChildUpdateFields, AddPrefixToKeys, UnionToIntersection } from '../src/lite-api/types';
 export { FieldPath, documentId } from '../src/lite-api/field_path';

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

@@ -14,4 +14,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export { endAt, endBefore, startAfter, startAt, limitToLast, limit, orderBy, OrderByDirection, where, WhereFilterOp, query, QueryConstraint, QueryConstraintType } from '../lite-api/query';
+export { and, endAt, endBefore, startAfter, startAt, limitToLast, limit, or, orderBy, OrderByDirection, where, WhereFilterOp, query, QueryCompositeFilterConstraint, QueryConstraint, QueryConstraintType, QueryFilterConstraint, QueryFieldFilterConstraint, QueryOrderByConstraint, QueryLimitConstraint, QueryStartAtConstraint, QueryEndAtConstraint, QueryNonFilterConstraint } from '../lite-api/query';

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

@@ -83,7 +83,8 @@ export declare function getDocFromServer<T>(reference: DocumentReference<T>): Pr
 export declare function getDocs<T>(query: Query<T>): Promise<QuerySnapshot<T>>;
 /**
  * Executes the query and returns the results as a `QuerySnapshot` from cache.
- * Returns an error if the document is not currently cached.
+ * Returns an empty result set if no documents matching the query are currently
+ * cached.
  *
  * @returns A `Promise` that will be resolved with the results of the query.
  */

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

@@ -22,7 +22,7 @@ export { LoadBundleTask, LoadBundleTaskProgress, TaskState } from './api/bundle'
 export { FirestoreSettings, PersistenceSettings } from './api/settings';
 export { DocumentChange, DocumentSnapshot, QueryDocumentSnapshot, QuerySnapshot, snapshotEqual, SnapshotOptions, FirestoreDataConverter, DocumentChangeType, SnapshotMetadata } from './api/snapshot';
 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 { and, endAt, endBefore, startAt, startAfter, limit, limitToLast, where, or, orderBy, query, QueryConstraint, QueryConstraintType, QueryCompositeFilterConstraint, QueryFilterConstraint, QueryFieldFilterConstraint, QueryOrderByConstraint, QueryLimitConstraint, QueryNonFilterConstraint, QueryStartAtConstraint, QueryEndAtConstraint, OrderByDirection, WhereFilterOp } from './api/filter';
 export { Unsubscribe, SnapshotListenOptions } from './api/reference_impl';
 export { TransactionOptions } from './api/transaction_options';
 export { runTransaction, Transaction } from './api/transaction';