@firebase/firestore 3.7.3 → 3.8.0

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

@@ -14,9 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Bound } from '../core/bound';
 import { DatabaseId } from '../core/database_info';
-import { Query as InternalQuery } from '../core/query';
-import { Bound, Direction, FieldFilter, Operator, OrderBy } from '../core/target';
+import { CompositeOperator, FieldFilter, Filter, Operator } from '../core/filter';
+import { Direction, OrderBy } from '../core/order_by';
+import { LimitType, Query as InternalQuery } from '../core/query';
 import { Document } from '../model/document';
 import { FieldPath as InternalFieldPath } from '../model/path';
 import { FieldPath } from './field_path';
@@ -26,33 +28,82 @@ import { UserDataReader } from './user_data_reader';
 export declare function validateHasExplicitOrderByForLimitToLast(query: InternalQuery): void;
 /** Describes the different query constraints available in this SDK. */
 export declare type QueryConstraintType = 'where' | 'orderBy' | 'limit' | 'limitToLast' | 'startAt' | 'startAfter' | 'endAt' | 'endBefore';
+/**
+ * An `AppliableConstraint` is an abstraction of a constraint that can be applied
+ * to a Firestore query.
+ */
+export 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>;
+}
 /**
  * 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>;
 }
 /**
- * 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 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 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.
  */
 export declare function query<T>(query: Query<T>, ...queryConstraints: QueryConstraint[]): Query<T>;
+/**
+ * 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: InternalFieldPath, _op: Operator, _value: unknown);
+    static _create(_field: InternalFieldPath, _op: Operator, _value: unknown): QueryFieldFilterConstraint;
+    _apply<T>(query: Query<T>): Query<T>;
+    _parse<T>(query: Query<T>): FieldFilter;
+}
 /**
  * Filter conditions in a {@link where} clause are specified using the
  * strings '&lt;', '&lt;=', '==', '!=', '&gt;=', '&gt;', 'array-contains', 'in',
@@ -60,129 +111,284 @@ export declare function query<T>(query: Query<T>, ...queryConstraints: QueryCons
  */
 export declare type WhereFilterOp = '<' | '<=' | '==' | '!=' | '>=' | '>' | 'array-contains' | 'in' | 'array-contains-any' | 'not-in';
 /**
- * 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): QueryFieldFilterConstraint;
+/**
+ * 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;
+}
+/**
+ * `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;
+/**
+ * `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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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 function where(fieldPath: string | FieldPath, opStr: WhereFilterOp, value: unknown): QueryConstraint;
+export declare class QueryOrderByConstraint extends QueryConstraint {
+    private readonly _field;
+    private _direction;
+    /** The type of this query constraint */
+    readonly type = "orderBy";
+    /**
+     * @internal
+     */
+    protected constructor(_field: InternalFieldPath, _direction: Direction);
+    static _create(_field: InternalFieldPath, _direction: Direction): QueryOrderByConstraint;
+    _apply<T>(query: Query<T>): Query<T>;
+}
 /**
  * The direction of a {@link orderBy} clause is specified as 'desc' or 'asc'
  * (descending or ascending).
  */
 export declare type OrderByDirection = 'desc' | 'asc';
 /**
- * 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;
 /**
- * Creates a {@link QueryConstraint} that only returns the first matching documents.
+ * 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>;
+}
+/**
+ * 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;
 /**
- * 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.
+ * 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<unknown>>, _inclusive: boolean);
+    static _create(type: 'startAt' | 'startAfter', _docOrFields: Array<unknown | DocumentSnapshot<unknown>>, _inclusive: boolean): QueryStartAtConstraint;
+    _apply<T>(query: Query<T>): Query<T>;
+}
+/**
+ * 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<unknown>): QueryConstraint;
+export declare function startAt(snapshot: DocumentSnapshot<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;
 /**
- * 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<unknown>): QueryConstraint;
+export declare function startAfter(snapshot: DocumentSnapshot<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 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.
+ * 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<unknown>>, _inclusive: boolean);
+    static _create(type: 'endBefore' | 'endAt', _docOrFields: Array<unknown | DocumentSnapshot<unknown>>, _inclusive: boolean): QueryEndAtConstraint;
+    _apply<T>(query: Query<T>): Query<T>;
+}
+/**
+ * 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<unknown>): QueryConstraint;
+export declare function endBefore(snapshot: DocumentSnapshot<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;
 /**
- * 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<unknown>): QueryConstraint;
+export declare function endAt(snapshot: DocumentSnapshot<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;
 export declare function newQueryFilter(query: InternalQuery, methodName: string, dataReader: UserDataReader, databaseId: DatabaseId, fieldPath: InternalFieldPath, op: Operator, value: unknown): FieldFilter;
 export declare function newQueryOrderBy(query: InternalQuery, fieldPath: InternalFieldPath, direction: Direction): OrderBy;
 /**
@@ -201,3 +407,4 @@ export declare function newQueryBoundFromDocument(query: InternalQuery, database
  * Converts a list of field values to a `Bound` for the given query.
  */
 export declare function newQueryBoundFromFields(query: InternalQuery, databaseId: DatabaseId, dataReader: UserDataReader, methodName: string, values: unknown[], inclusive: boolean): Bound;
+export declare function validateQueryFilterConstraint(functionName: string, queryConstraint: AppliableConstraint): void;

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

@@ -17,6 +17,7 @@
 import { User } from '../auth/user';
 import { DatabaseId } from '../core/database_info';
 import { Target } from '../core/target';
+import { IndexEntry } from '../index/index_entry';
 import { DocumentMap } from '../model/collections';
 import { DocumentKey } from '../model/document_key';
 import { FieldIndex, IndexOffset } from '../model/field_index';
@@ -128,6 +129,7 @@ export declare class IndexedDbIndexManager implements IndexManager {
      * '[foo > 2 && foo != 3]` becomes  `[foo > 2 && < 3, foo > 3]`.
      */
     private createRange;
+    isRangeMatchable(lowerBound: IndexEntry, upperBound: IndexEntry): boolean;
     getMinOffsetFromCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string): PersistencePromise<IndexOffset>;
     getMinOffset(transaction: PersistenceTransaction, target: Target): PersistencePromise<IndexOffset>;
 }

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

@@ -121,6 +121,4 @@ export declare class LocalDocumentsView {
     private getDocumentsMatchingDocumentQuery;
     private getDocumentsMatchingCollectionGroupQuery;
     private getDocumentsMatchingCollectionQuery;
-    /** Returns a base document that can be used to apply `overlay`. */
-    private getBaseDocument;
 }

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

@@ -35,6 +35,12 @@ export interface Document {
      * `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. */
@@ -85,6 +91,7 @@ export declare class MutableDocument implements Document {
     private documentType;
     version: SnapshotVersion;
     readTime: SnapshotVersion;
+    createTime: SnapshotVersion;
     data: ObjectValue;
     private documentState;
     private constructor();
@@ -97,7 +104,7 @@ export declare class MutableDocument implements Document {
      * 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;
     /**

package/dist/lite/packages/firestore/src/protos/firestore_proto_api.d.ts

@@ -23,7 +23,7 @@ export declare type Timestamp = string | {
     seconds?: string | number;
     nanos?: number;
 };
-export declare type CompositeFilterOp = 'OPERATOR_UNSPECIFIED' | 'AND';
+export declare type CompositeFilterOp = 'OPERATOR_UNSPECIFIED' | 'AND' | 'OR';
 export interface ICompositeFilterOpEnum {
     OPERATOR_UNSPECIFIED: CompositeFilterOp;
     AND: CompositeFilterOp;

package/dist/lite/packages/firestore/src/remote/serializer.d.ts

@@ -15,9 +15,11 @@
  * limitations under the License.
  */
 import { DatabaseId } from '../core/database_info';
+import { CompositeFilter, CompositeOperator, FieldFilter, Filter, Operator } from '../core/filter';
+import { Direction, OrderBy } from '../core/order_by';
 import { Query } from '../core/query';
 import { SnapshotVersion } from '../core/snapshot_version';
-import { Direction, FieldFilter, Filter, Operator, OrderBy, Target } from '../core/target';
+import { Target } from '../core/target';
 import { Timestamp } from '../lite-api/timestamp';
 import { TargetData } from '../local/target_data';
 import { MutableDocument } from '../model/document';
@@ -26,7 +28,7 @@ import { FieldMask } from '../model/field_mask';
 import { Mutation, MutationResult } from '../model/mutation';
 import { ObjectValue } from '../model/object_value';
 import { FieldPath, ResourcePath } from '../model/path';
-import { ApiClientObjectMap as ProtoApiClientObjectMap, BatchGetDocumentsResponse as ProtoBatchGetDocumentsResponse, Document as ProtoDocument, DocumentMask as ProtoDocumentMask, DocumentsTarget as ProtoDocumentsTarget, FieldFilterOp as ProtoFieldFilterOp, FieldReference as ProtoFieldReference, Filter as ProtoFilter, ListenResponse as ProtoListenResponse, Order as ProtoOrder, OrderDirection as ProtoOrderDirection, QueryTarget as ProtoQueryTarget, RunAggregationQueryRequest as ProtoRunAggregationQueryRequest, Target as ProtoTarget, Timestamp as ProtoTimestamp, Write as ProtoWrite, WriteResult as ProtoWriteResult } from '../protos/firestore_proto_api';
+import { ApiClientObjectMap as ProtoApiClientObjectMap, BatchGetDocumentsResponse as ProtoBatchGetDocumentsResponse, CompositeFilterOp as ProtoCompositeFilterOp, Document as ProtoDocument, DocumentMask as ProtoDocumentMask, DocumentsTarget as ProtoDocumentsTarget, FieldFilterOp as ProtoFieldFilterOp, FieldReference as ProtoFieldReference, Filter as ProtoFilter, ListenResponse as ProtoListenResponse, Order as ProtoOrder, OrderDirection as ProtoOrderDirection, QueryTarget as ProtoQueryTarget, RunAggregationQueryRequest as ProtoRunAggregationQueryRequest, Target as ProtoTarget, Timestamp as ProtoTimestamp, Write as ProtoWrite, WriteResult as ProtoWriteResult } from '../protos/firestore_proto_api';
 import { ByteString } from '../util/byte_string';
 import { Serializer } from './number_serializer';
 import { WatchChange } from './watch_change';
@@ -90,14 +92,19 @@ export declare function toTarget(serializer: JsonProtoSerializer, targetData: Ta
 export declare function toDirection(dir: Direction): ProtoOrderDirection;
 export declare function fromDirection(dir: ProtoOrderDirection | undefined): Direction | undefined;
 export declare function toOperatorName(op: Operator): ProtoFieldFilterOp;
+export declare function toCompositeOperatorName(op: CompositeOperator): ProtoCompositeFilterOp;
 export declare function fromOperatorName(op: ProtoFieldFilterOp): Operator;
+export declare function fromCompositeOperatorName(op: ProtoCompositeFilterOp): CompositeOperator;
 export declare function toFieldPathReference(path: FieldPath): ProtoFieldReference;
 export declare function fromFieldPathReference(fieldReference: ProtoFieldReference): FieldPath;
 export declare function toPropertyOrder(orderBy: OrderBy): ProtoOrder;
 export declare function fromPropertyOrder(orderBy: ProtoOrder): OrderBy;
-export declare function fromFieldFilter(filter: ProtoFilter): Filter;
+export declare function toFilter(filter: Filter): ProtoFilter;
+export declare function toCompositeFilter(filter: CompositeFilter): ProtoFilter;
 export declare function toUnaryOrFieldFilter(filter: FieldFilter): ProtoFilter;
 export declare function fromUnaryFilter(filter: ProtoFilter): Filter;
+export declare function fromFieldFilter(filter: ProtoFilter): FieldFilter;
+export declare function fromCompositeFilter(filter: ProtoFilter): CompositeFilter;
 export declare function toDocumentMask(fieldMask: FieldMask): ProtoDocumentMask;
 export declare function fromDocumentMask(proto: ProtoDocumentMask): FieldMask;
 export declare function isValidResourceName(path: ResourcePath): boolean;

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

@@ -0,0 +1,52 @@
+/**
+ * @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 { CompositeFilter, Filter } from '../core/filter';
+/**
+ * Provides utility functions that help with boolean logic transformations needed for handling
+ * complex filters used in queries.
+ */
+/**
+ * The `in` filter is only a syntactic sugar over a disjunction of equalities. For instance: `a in
+ * [1,2,3]` is in fact `a==1 || a==2 || a==3`. This method expands any `in` filter in the given
+ * input into a disjunction of equality filters and returns the expanded filter.
+ */
+export declare function computeInExpansion(filter: Filter): Filter;
+/**
+ * Given a composite filter, returns the list of terms in its disjunctive normal form.
+ *
+ * <p>Each element in the return value is one term of the resulting DNF. For instance: For the
+ * input: (A || B) && C, the DNF form is: (A && C) || (B && C), and the return value is a list
+ * with two elements: a composite filter that performs (A && C), and a composite filter that
+ * performs (B && C).
+ *
+ * @param filter the composite filter to calculate DNF transform for.
+ * @return the terms in the DNF transform.
+ */
+export declare function getDnfTerms(filter: CompositeFilter): Filter[];
+export declare function computeDistributedNormalForm(filter: Filter): Filter;
+export declare function applyDistribution(lhs: Filter, rhs: Filter): Filter;
+/**
+ * Applies the associativity property to the given filter and returns the resulting filter.
+ *
+ * <ul>
+ *   <li>A | (B | C) == (A | B) | C == (A | B | C)
+ *   <li>A & (B & C) == (A & B) & C == (A & B & C)
+ * </ul>
+ *
+ * <p>For more info, visit: https://en.wikipedia.org/wiki/Associative_property#Propositional_logic
+ */
+export declare function applyAssociation(filter: Filter): Filter;

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

@@ -39,7 +39,7 @@ export interface WindowLike {
 }
 /** The subset of the browser's Document interface used by the SDK. */
 export interface DocumentLike {
-    readonly visibilityState: VisibilityState;
+    readonly visibilityState: DocumentVisibilityState;
     addEventListener(type: string, listener: EventListener): void;
     removeEventListener(type: string, listener: EventListener): void;
 }

package/dist/lite/packages/firestore/test/lite/helpers.d.ts

@@ -36,6 +36,6 @@ export declare const postConverter: {
     fromFirestore(snapshot: QueryDocumentSnapshot<DocumentData>): Post;
 };
 export declare const postConverterMerge: {
-    toFirestore(post: PartialWithFieldValue<Post>, options?: SetOptions | undefined): DocumentData;
+    toFirestore(post: PartialWithFieldValue<Post>, options?: SetOptions): DocumentData;
     fromFirestore(snapshot: QueryDocumentSnapshot<DocumentData>): Post;
 };