@firebase/firestore 3.7.3 → 3.8.0-canary.06dc1364d

package/dist/index.node.cjs.js

@@ -33,7 +33,7 @@ var grpc__namespace = /*#__PURE__*/_interopNamespace(grpc);
 var protoLoader__namespace = /*#__PURE__*/_interopNamespace(protoLoader);
 
 const name = "@firebase/firestore";
-const version$1 = "3.7.3";
+const version$1 = "3.8.0-canary.06dc1364d";
 
 /**
  * @license
@@ -86,7 +86,7 @@ User.GOOGLE_CREDENTIALS = new User('google-credentials-uid');
 User.FIRST_PARTY = new User('first-party-uid');
 User.MOCK_USER = new User('mock-user');
 
-const version = "9.14.0";
+const version = "9.15.0-canary.06dc1364d";
 
 /**
  * @license
@@ -1524,11 +1524,11 @@ class FieldIndex {
 FieldIndex.UNKNOWN_ID = -1;
 /** Returns the ArrayContains/ArrayContainsAny segment for this index. */
 function fieldIndexGetArraySegment(fieldIndex) {
-    return fieldIndex.fields.find(s => s.kind === 2 /* CONTAINS */);
+    return fieldIndex.fields.find(s => s.kind === 2 /* IndexKind.CONTAINS */);
 }
 /** Returns all directional (ascending/descending) segments for this index. */
 function fieldIndexGetDirectionalSegments(fieldIndex) {
-    return fieldIndex.fields.filter(s => s.kind !== 2 /* CONTAINS */);
+    return fieldIndex.fields.filter(s => s.kind !== 2 /* IndexKind.CONTAINS */);
 }
 /**
  * Returns the order of the document key component for the given index.
@@ -1538,7 +1538,7 @@ function fieldIndexGetDirectionalSegments(fieldIndex) {
 function fieldIndexGetKeyOrder(fieldIndex) {
     const directionalSegments = fieldIndexGetDirectionalSegments(fieldIndex);
     return directionalSegments.length === 0
-        ? 0 /* ASCENDING */
+        ? 0 /* IndexKind.ASCENDING */
         : directionalSegments[directionalSegments.length - 1].kind;
 }
 /**
@@ -2652,7 +2652,7 @@ class IndexBackfillerScheduler {
     }
     schedule(delay) {
         logDebug(LOG_TAG$h, `Scheduled in ${delay}ms`);
-        this.task = this.asyncQueue.enqueueAfterDelay("index_backfill" /* IndexBackfill */, delay, async () => {
+        this.task = this.asyncQueue.enqueueAfterDelay("index_backfill" /* TimerId.IndexBackfill */, delay, async () => {
             this.task = null;
             try {
                 const documentsProcessed = await this.backfiller.backfill();
@@ -4448,40 +4448,40 @@ const MIN_VALUE = {
 /** Extracts the backend's type order for the provided value. */
 function typeOrder(value) {
     if ('nullValue' in value) {
-        return 0 /* NullValue */;
+        return 0 /* TypeOrder.NullValue */;
     }
     else if ('booleanValue' in value) {
-        return 1 /* BooleanValue */;
+        return 1 /* TypeOrder.BooleanValue */;
     }
     else if ('integerValue' in value || 'doubleValue' in value) {
-        return 2 /* NumberValue */;
+        return 2 /* TypeOrder.NumberValue */;
     }
     else if ('timestampValue' in value) {
-        return 3 /* TimestampValue */;
+        return 3 /* TypeOrder.TimestampValue */;
     }
     else if ('stringValue' in value) {
-        return 5 /* StringValue */;
+        return 5 /* TypeOrder.StringValue */;
     }
     else if ('bytesValue' in value) {
-        return 6 /* BlobValue */;
+        return 6 /* TypeOrder.BlobValue */;
     }
     else if ('referenceValue' in value) {
-        return 7 /* RefValue */;
+        return 7 /* TypeOrder.RefValue */;
     }
     else if ('geoPointValue' in value) {
-        return 8 /* GeoPointValue */;
+        return 8 /* TypeOrder.GeoPointValue */;
     }
     else if ('arrayValue' in value) {
-        return 9 /* ArrayValue */;
+        return 9 /* TypeOrder.ArrayValue */;
     }
     else if ('mapValue' in value) {
         if (isServerTimestamp(value)) {
-            return 4 /* ServerTimestampValue */;
+            return 4 /* TypeOrder.ServerTimestampValue */;
         }
         else if (isMaxValue(value)) {
-            return 9007199254740991 /* MaxValue */;
+            return 9007199254740991 /* TypeOrder.MaxValue */;
         }
-        return 10 /* ObjectValue */;
+        return 10 /* TypeOrder.ObjectValue */;
     }
     else {
         return fail();
@@ -4498,29 +4498,29 @@ function valueEquals(left, right) {
         return false;
     }
     switch (leftType) {
-        case 0 /* NullValue */:
+        case 0 /* TypeOrder.NullValue */:
             return true;
-        case 1 /* BooleanValue */:
+        case 1 /* TypeOrder.BooleanValue */:
             return left.booleanValue === right.booleanValue;
-        case 4 /* ServerTimestampValue */:
+        case 4 /* TypeOrder.ServerTimestampValue */:
             return getLocalWriteTime(left).isEqual(getLocalWriteTime(right));
-        case 3 /* TimestampValue */:
+        case 3 /* TypeOrder.TimestampValue */:
             return timestampEquals(left, right);
-        case 5 /* StringValue */:
+        case 5 /* TypeOrder.StringValue */:
             return left.stringValue === right.stringValue;
-        case 6 /* BlobValue */:
+        case 6 /* TypeOrder.BlobValue */:
             return blobEquals(left, right);
-        case 7 /* RefValue */:
+        case 7 /* TypeOrder.RefValue */:
             return left.referenceValue === right.referenceValue;
-        case 8 /* GeoPointValue */:
+        case 8 /* TypeOrder.GeoPointValue */:
             return geoPointEquals(left, right);
-        case 2 /* NumberValue */:
+        case 2 /* TypeOrder.NumberValue */:
             return numberEquals(left, right);
-        case 9 /* ArrayValue */:
+        case 9 /* TypeOrder.ArrayValue */:
             return arrayEquals(left.arrayValue.values || [], right.arrayValue.values || [], valueEquals);
-        case 10 /* ObjectValue */:
+        case 10 /* TypeOrder.ObjectValue */:
             return objectEquals(left, right);
-        case 9007199254740991 /* MaxValue */:
+        case 9007199254740991 /* TypeOrder.MaxValue */:
             return true;
         default:
             return fail();
@@ -4593,28 +4593,28 @@ function valueCompare(left, right) {
         return primitiveComparator(leftType, rightType);
     }
     switch (leftType) {
-        case 0 /* NullValue */:
-        case 9007199254740991 /* MaxValue */:
+        case 0 /* TypeOrder.NullValue */:
+        case 9007199254740991 /* TypeOrder.MaxValue */:
             return 0;
-        case 1 /* BooleanValue */:
+        case 1 /* TypeOrder.BooleanValue */:
             return primitiveComparator(left.booleanValue, right.booleanValue);
-        case 2 /* NumberValue */:
+        case 2 /* TypeOrder.NumberValue */:
             return compareNumbers(left, right);
-        case 3 /* TimestampValue */:
+        case 3 /* TypeOrder.TimestampValue */:
             return compareTimestamps(left.timestampValue, right.timestampValue);
-        case 4 /* ServerTimestampValue */:
+        case 4 /* TypeOrder.ServerTimestampValue */:
             return compareTimestamps(getLocalWriteTime(left), getLocalWriteTime(right));
-        case 5 /* StringValue */:
+        case 5 /* TypeOrder.StringValue */:
             return primitiveComparator(left.stringValue, right.stringValue);
-        case 6 /* BlobValue */:
+        case 6 /* TypeOrder.BlobValue */:
             return compareBlobs(left.bytesValue, right.bytesValue);
-        case 7 /* RefValue */:
+        case 7 /* TypeOrder.RefValue */:
             return compareReferences(left.referenceValue, right.referenceValue);
-        case 8 /* GeoPointValue */:
+        case 8 /* TypeOrder.GeoPointValue */:
             return compareGeoPoints(left.geoPointValue, right.geoPointValue);
-        case 9 /* ArrayValue */:
+        case 9 /* TypeOrder.ArrayValue */:
             return compareArrays(left.arrayValue, right.arrayValue);
-        case 10 /* ObjectValue */:
+        case 10 /* TypeOrder.ObjectValue */:
             return compareMaps(left.mapValue, right.mapValue);
         default:
             throw fail();
@@ -5167,11 +5167,12 @@ function extractFieldMask(value) {
  * from all views.
  */
 class MutableDocument {
-    constructor(key, documentType, version, readTime, data, documentState) {
+    constructor(key, documentType, version, readTime, createTime, data, documentState) {
         this.key = key;
         this.documentType = documentType;
         this.version = version;
         this.readTime = readTime;
+        this.createTime = createTime;
         this.data = data;
         this.documentState = documentState;
     }
@@ -5180,18 +5181,27 @@ class MutableDocument {
      * base document for mutations.
      */
     static newInvalidDocument(documentKey) {
-        return new MutableDocument(documentKey, 0 /* INVALID */, SnapshotVersion.min(), SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
+        return new MutableDocument(documentKey, 0 /* DocumentType.INVALID */, 
+        /* version */ SnapshotVersion.min(), 
+        /* readTime */ SnapshotVersion.min(), 
+        /* createTime */ SnapshotVersion.min(), ObjectValue.empty(), 0 /* DocumentState.SYNCED */);
     }
     /**
      * Creates a new document that is known to exist with the given data at the
      * given version.
      */
-    static newFoundDocument(documentKey, version, value) {
-        return new MutableDocument(documentKey, 1 /* FOUND_DOCUMENT */, version, SnapshotVersion.min(), value, 0 /* SYNCED */);
+    static newFoundDocument(documentKey, version, createTime, value) {
+        return new MutableDocument(documentKey, 1 /* DocumentType.FOUND_DOCUMENT */, 
+        /* version */ version, 
+        /* readTime */ SnapshotVersion.min(), 
+        /* createTime */ createTime, value, 0 /* DocumentState.SYNCED */);
     }
     /** Creates a new document that is known to not exist at the given version. */
     static newNoDocument(documentKey, version) {
-        return new MutableDocument(documentKey, 2 /* NO_DOCUMENT */, version, SnapshotVersion.min(), ObjectValue.empty(), 0 /* SYNCED */);
+        return new MutableDocument(documentKey, 2 /* DocumentType.NO_DOCUMENT */, 
+        /* version */ version, 
+        /* readTime */ SnapshotVersion.min(), 
+        /* createTime */ SnapshotVersion.min(), ObjectValue.empty(), 0 /* DocumentState.SYNCED */);
     }
     /**
      * Creates a new document that is known to exist at the given version but
@@ -5199,17 +5209,30 @@ class MutableDocument {
      * base document).
      */
     static newUnknownDocument(documentKey, version) {
-        return new MutableDocument(documentKey, 3 /* UNKNOWN_DOCUMENT */, version, SnapshotVersion.min(), ObjectValue.empty(), 2 /* HAS_COMMITTED_MUTATIONS */);
+        return new MutableDocument(documentKey, 3 /* DocumentType.UNKNOWN_DOCUMENT */, 
+        /* version */ version, 
+        /* readTime */ SnapshotVersion.min(), 
+        /* createTime */ SnapshotVersion.min(), ObjectValue.empty(), 2 /* DocumentState.HAS_COMMITTED_MUTATIONS */);
     }
     /**
      * Changes the document type to indicate that it exists and that its version
      * and data are known.
      */
     convertToFoundDocument(version, value) {
+        // If a document is switching state from being an invalid or deleted
+        // document to a valid (FOUND_DOCUMENT) document, either due to receiving an
+        // update from Watch or due to applying a local set mutation on top
+        // of a deleted document, our best guess about its createTime would be the
+        // version at which the document transitioned to a FOUND_DOCUMENT.
+        if (this.createTime.isEqual(SnapshotVersion.min()) &&
+            (this.documentType === 2 /* DocumentType.NO_DOCUMENT */ ||
+                this.documentType === 0 /* DocumentType.INVALID */)) {
+            this.createTime = version;
+        }
         this.version = version;
-        this.documentType = 1 /* FOUND_DOCUMENT */;
+        this.documentType = 1 /* DocumentType.FOUND_DOCUMENT */;
         this.data = value;
-        this.documentState = 0 /* SYNCED */;
+        this.documentState = 0 /* DocumentState.SYNCED */;
         return this;
     }
     /**
@@ -5218,9 +5241,9 @@ class MutableDocument {
      */
     convertToNoDocument(version) {
         this.version = version;
-        this.documentType = 2 /* NO_DOCUMENT */;
+        this.documentType = 2 /* DocumentType.NO_DOCUMENT */;
         this.data = ObjectValue.empty();
-        this.documentState = 0 /* SYNCED */;
+        this.documentState = 0 /* DocumentState.SYNCED */;
         return this;
     }
     /**
@@ -5230,17 +5253,17 @@ class MutableDocument {
      */
     convertToUnknownDocument(version) {
         this.version = version;
-        this.documentType = 3 /* UNKNOWN_DOCUMENT */;
+        this.documentType = 3 /* DocumentType.UNKNOWN_DOCUMENT */;
         this.data = ObjectValue.empty();
-        this.documentState = 2 /* HAS_COMMITTED_MUTATIONS */;
+        this.documentState = 2 /* DocumentState.HAS_COMMITTED_MUTATIONS */;
         return this;
     }
     setHasCommittedMutations() {
-        this.documentState = 2 /* HAS_COMMITTED_MUTATIONS */;
+        this.documentState = 2 /* DocumentState.HAS_COMMITTED_MUTATIONS */;
         return this;
     }
     setHasLocalMutations() {
-        this.documentState = 1 /* HAS_LOCAL_MUTATIONS */;
+        this.documentState = 1 /* DocumentState.HAS_LOCAL_MUTATIONS */;
         this.version = SnapshotVersion.min();
         return this;
     }
@@ -5249,25 +5272,25 @@ class MutableDocument {
         return this;
     }
     get hasLocalMutations() {
-        return this.documentState === 1 /* HAS_LOCAL_MUTATIONS */;
+        return this.documentState === 1 /* DocumentState.HAS_LOCAL_MUTATIONS */;
     }
     get hasCommittedMutations() {
-        return this.documentState === 2 /* HAS_COMMITTED_MUTATIONS */;
+        return this.documentState === 2 /* DocumentState.HAS_COMMITTED_MUTATIONS */;
     }
     get hasPendingWrites() {
         return this.hasLocalMutations || this.hasCommittedMutations;
     }
     isValidDocument() {
-        return this.documentType !== 0 /* INVALID */;
+        return this.documentType !== 0 /* DocumentType.INVALID */;
     }
     isFoundDocument() {
-        return this.documentType === 1 /* FOUND_DOCUMENT */;
+        return this.documentType === 1 /* DocumentType.FOUND_DOCUMENT */;
     }
     isNoDocument() {
-        return this.documentType === 2 /* NO_DOCUMENT */;
+        return this.documentType === 2 /* DocumentType.NO_DOCUMENT */;
     }
     isUnknownDocument() {
-        return this.documentType === 3 /* UNKNOWN_DOCUMENT */;
+        return this.documentType === 3 /* DocumentType.UNKNOWN_DOCUMENT */;
     }
     isEqual(other) {
         return (other instanceof MutableDocument &&
@@ -5278,10 +5301,11 @@ class MutableDocument {
             this.data.isEqual(other.data));
     }
     mutableCopy() {
-        return new MutableDocument(this.key, this.documentType, this.version, this.readTime, this.data.clone(), this.documentState);
+        return new MutableDocument(this.key, this.documentType, this.version, this.readTime, this.createTime, this.data.clone(), this.documentState);
     }
     toString() {
         return (`Document(${this.key}, ${this.version}, ${JSON.stringify(this.data.value)}, ` +
+            `{createTime: ${this.createTime}}), ` +
             `{documentType: ${this.documentType}}), ` +
             `{documentState: ${this.documentState}})`);
     }
@@ -5303,7 +5327,7 @@ function compareDocumentsByField(field, d1, d2) {
 
 /**
  * @license
- * Copyright 2019 Google LLC
+ * 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.
@@ -5317,453 +5341,353 @@ function compareDocumentsByField(field, d1, d2) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// Visible for testing
-class TargetImpl {
-    constructor(path, collectionGroup = null, orderBy = [], filters = [], limit = null, startAt = null, endAt = null) {
-        this.path = path;
-        this.collectionGroup = collectionGroup;
-        this.orderBy = orderBy;
-        this.filters = filters;
-        this.limit = limit;
-        this.startAt = startAt;
-        this.endAt = endAt;
-        this.memoizedCanonicalId = null;
+/**
+ * Represents a bound of a query.
+ *
+ * The bound is specified with the given components representing a position and
+ * whether it's just before or just after the position (relative to whatever the
+ * query order is).
+ *
+ * The position represents a logical index position for a query. It's a prefix
+ * of values for the (potentially implicit) order by clauses of a query.
+ *
+ * Bound provides a function to determine whether a document comes before or
+ * after a bound. This is influenced by whether the position is just before or
+ * just after the provided values.
+ */
+class Bound {
+    constructor(position, inclusive) {
+        this.position = position;
+        this.inclusive = inclusive;
     }
 }
+function boundCompareToDocument(bound, orderBy, doc) {
+    let comparison = 0;
+    for (let i = 0; i < bound.position.length; i++) {
+        const orderByComponent = orderBy[i];
+        const component = bound.position[i];
+        if (orderByComponent.field.isKeyField()) {
+            comparison = DocumentKey.comparator(DocumentKey.fromName(component.referenceValue), doc.key);
+        }
+        else {
+            const docValue = doc.data.field(orderByComponent.field);
+            comparison = valueCompare(component, docValue);
+        }
+        if (orderByComponent.dir === "desc" /* Direction.DESCENDING */) {
+            comparison = comparison * -1;
+        }
+        if (comparison !== 0) {
+            break;
+        }
+    }
+    return comparison;
+}
 /**
- * Initializes a Target with a path and optional additional query constraints.
- * Path must currently be empty if this is a collection group query.
+ * Returns true if a document sorts after a bound using the provided sort
+ * order.
+ */
+function boundSortsAfterDocument(bound, orderBy, doc) {
+    const comparison = boundCompareToDocument(bound, orderBy, doc);
+    return bound.inclusive ? comparison >= 0 : comparison > 0;
+}
+/**
+ * Returns true if a document sorts before a bound using the provided sort
+ * order.
+ */
+function boundSortsBeforeDocument(bound, orderBy, doc) {
+    const comparison = boundCompareToDocument(bound, orderBy, doc);
+    return bound.inclusive ? comparison <= 0 : comparison < 0;
+}
+function boundEquals(left, right) {
+    if (left === null) {
+        return right === null;
+    }
+    else if (right === null) {
+        return false;
+    }
+    if (left.inclusive !== right.inclusive ||
+        left.position.length !== right.position.length) {
+        return false;
+    }
+    for (let i = 0; i < left.position.length; i++) {
+        const leftPosition = left.position[i];
+        const rightPosition = right.position[i];
+        if (!valueEquals(leftPosition, rightPosition)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * @license
+ * Copyright 2022 Google LLC
  *
- * NOTE: you should always construct `Target` from `Query.toTarget` instead of
- * using this factory method, because `Query` provides an implicit `orderBy`
- * property.
+ * 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.
  */
-function newTarget(path, collectionGroup = null, orderBy = [], filters = [], limit = null, startAt = null, endAt = null) {
-    return new TargetImpl(path, collectionGroup, orderBy, filters, limit, startAt, endAt);
+class Filter {
 }
-function canonifyTarget(target) {
-    const targetImpl = debugCast(target);
-    if (targetImpl.memoizedCanonicalId === null) {
-        let str = targetImpl.path.canonicalString();
-        if (targetImpl.collectionGroup !== null) {
-            str += '|cg:' + targetImpl.collectionGroup;
+class FieldFilter extends Filter {
+    constructor(field, op, value) {
+        super();
+        this.field = field;
+        this.op = op;
+        this.value = value;
+    }
+    /**
+     * Creates a filter based on the provided arguments.
+     */
+    static create(field, op, value) {
+        if (field.isKeyField()) {
+            if (op === "in" /* Operator.IN */ || op === "not-in" /* Operator.NOT_IN */) {
+                return this.createKeyFieldInFilter(field, op, value);
+            }
+            else {
+                return new KeyFieldFilter(field, op, value);
+            }
         }
-        str += '|f:';
-        str += targetImpl.filters.map(f => canonifyFilter(f)).join(',');
-        str += '|ob:';
-        str += targetImpl.orderBy.map(o => canonifyOrderBy(o)).join(',');
-        if (!isNullOrUndefined(targetImpl.limit)) {
-            str += '|l:';
-            str += targetImpl.limit;
+        else if (op === "array-contains" /* Operator.ARRAY_CONTAINS */) {
+            return new ArrayContainsFilter(field, value);
         }
-        if (targetImpl.startAt) {
-            str += '|lb:';
-            str += targetImpl.startAt.inclusive ? 'b:' : 'a:';
-            str += targetImpl.startAt.position.map(p => canonicalId(p)).join(',');
+        else if (op === "in" /* Operator.IN */) {
+            return new InFilter(field, value);
         }
-        if (targetImpl.endAt) {
-            str += '|ub:';
-            str += targetImpl.endAt.inclusive ? 'a:' : 'b:';
-            str += targetImpl.endAt.position.map(p => canonicalId(p)).join(',');
+        else if (op === "not-in" /* Operator.NOT_IN */) {
+            return new NotInFilter(field, value);
+        }
+        else if (op === "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */) {
+            return new ArrayContainsAnyFilter(field, value);
+        }
+        else {
+            return new FieldFilter(field, op, value);
         }
-        targetImpl.memoizedCanonicalId = str;
     }
-    return targetImpl.memoizedCanonicalId;
-}
-function stringifyTarget(target) {
-    let str = target.path.canonicalString();
-    if (target.collectionGroup !== null) {
-        str += ' collectionGroup=' + target.collectionGroup;
+    static createKeyFieldInFilter(field, op, value) {
+        return op === "in" /* Operator.IN */
+            ? new KeyFieldInFilter(field, value)
+            : new KeyFieldNotInFilter(field, value);
     }
-    if (target.filters.length > 0) {
-        str += `, filters: [${target.filters
-            .map(f => stringifyFilter(f))
-            .join(', ')}]`;
+    matches(doc) {
+        const other = doc.data.field(this.field);
+        // Types do not have to match in NOT_EQUAL filters.
+        if (this.op === "!=" /* Operator.NOT_EQUAL */) {
+            return (other !== null &&
+                this.matchesComparison(valueCompare(other, this.value)));
+        }
+        // Only compare types with matching backend order (such as double and int).
+        return (other !== null &&
+            typeOrder(this.value) === typeOrder(other) &&
+            this.matchesComparison(valueCompare(other, this.value)));
     }
-    if (!isNullOrUndefined(target.limit)) {
-        str += ', limit: ' + target.limit;
+    matchesComparison(comparison) {
+        switch (this.op) {
+            case "<" /* Operator.LESS_THAN */:
+                return comparison < 0;
+            case "<=" /* Operator.LESS_THAN_OR_EQUAL */:
+                return comparison <= 0;
+            case "==" /* Operator.EQUAL */:
+                return comparison === 0;
+            case "!=" /* Operator.NOT_EQUAL */:
+                return comparison !== 0;
+            case ">" /* Operator.GREATER_THAN */:
+                return comparison > 0;
+            case ">=" /* Operator.GREATER_THAN_OR_EQUAL */:
+                return comparison >= 0;
+            default:
+                return fail();
+        }
     }
-    if (target.orderBy.length > 0) {
-        str += `, orderBy: [${target.orderBy
-            .map(o => stringifyOrderBy(o))
-            .join(', ')}]`;
+    isInequality() {
+        return ([
+            "<" /* Operator.LESS_THAN */,
+            "<=" /* Operator.LESS_THAN_OR_EQUAL */,
+            ">" /* Operator.GREATER_THAN */,
+            ">=" /* Operator.GREATER_THAN_OR_EQUAL */,
+            "!=" /* Operator.NOT_EQUAL */,
+            "not-in" /* Operator.NOT_IN */
+        ].indexOf(this.op) >= 0);
     }
-    if (target.startAt) {
-        str += ', startAt: ';
-        str += target.startAt.inclusive ? 'b:' : 'a:';
-        str += target.startAt.position.map(p => canonicalId(p)).join(',');
+    getFlattenedFilters() {
+        return [this];
     }
-    if (target.endAt) {
-        str += ', endAt: ';
-        str += target.endAt.inclusive ? 'a:' : 'b:';
-        str += target.endAt.position.map(p => canonicalId(p)).join(',');
+    getFilters() {
+        return [this];
+    }
+    getFirstInequalityField() {
+        if (this.isInequality()) {
+            return this.field;
+        }
+        return null;
     }
-    return `Target(${str})`;
 }
-function targetEquals(left, right) {
-    if (left.limit !== right.limit) {
-        return false;
+class CompositeFilter extends Filter {
+    constructor(filters, op) {
+        super();
+        this.filters = filters;
+        this.op = op;
+        this.memoizedFlattenedFilters = null;
     }
-    if (left.orderBy.length !== right.orderBy.length) {
-        return false;
+    /**
+     * Creates a filter based on the provided arguments.
+     */
+    static create(filters, op) {
+        return new CompositeFilter(filters, op);
     }
-    for (let i = 0; i < left.orderBy.length; i++) {
-        if (!orderByEquals(left.orderBy[i], right.orderBy[i])) {
-            return false;
+    matches(doc) {
+        if (compositeFilterIsConjunction(this)) {
+            // For conjunctions, all filters must match, so return false if any filter doesn't match.
+            return this.filters.find(filter => !filter.matches(doc)) === undefined;
+        }
+        else {
+            // For disjunctions, at least one filter should match.
+            return this.filters.find(filter => filter.matches(doc)) !== undefined;
         }
     }
-    if (left.filters.length !== right.filters.length) {
-        return false;
-    }
-    for (let i = 0; i < left.filters.length; i++) {
-        if (!filterEquals(left.filters[i], right.filters[i])) {
-            return false;
+    getFlattenedFilters() {
+        if (this.memoizedFlattenedFilters !== null) {
+            return this.memoizedFlattenedFilters;
         }
+        this.memoizedFlattenedFilters = this.filters.reduce((result, subfilter) => {
+            return result.concat(subfilter.getFlattenedFilters());
+        }, []);
+        return this.memoizedFlattenedFilters;
     }
-    if (left.collectionGroup !== right.collectionGroup) {
-        return false;
+    // Returns a mutable copy of `this.filters`
+    getFilters() {
+        return Object.assign([], this.filters);
     }
-    if (!left.path.isEqual(right.path)) {
-        return false;
+    getFirstInequalityField() {
+        const found = this.findFirstMatchingFilter(filter => filter.isInequality());
+        if (found !== null) {
+            return found.field;
+        }
+        return null;
     }
-    if (!boundEquals(left.startAt, right.startAt)) {
-        return false;
+    // Performs a depth-first search to find and return the first FieldFilter in the composite filter
+    // that satisfies the predicate. Returns `null` if none of the FieldFilters satisfy the
+    // predicate.
+    findFirstMatchingFilter(predicate) {
+        for (const fieldFilter of this.getFlattenedFilters()) {
+            if (predicate(fieldFilter)) {
+                return fieldFilter;
+            }
+        }
+        return null;
     }
-    return boundEquals(left.endAt, right.endAt);
 }
-function targetIsDocumentTarget(target) {
-    return (DocumentKey.isDocumentKey(target.path) &&
-        target.collectionGroup === null &&
-        target.filters.length === 0);
+function compositeFilterIsConjunction(compositeFilter) {
+    return compositeFilter.op === "and" /* CompositeOperator.AND */;
 }
-/** Returns the field filters that target the given field path. */
-function targetGetFieldFiltersForPath(target, path) {
-    return target.filters.filter(f => f instanceof FieldFilter && f.field.isEqual(path));
+function compositeFilterIsDisjunction(compositeFilter) {
+    return compositeFilter.op === "or" /* CompositeOperator.OR */;
 }
 /**
- * Returns the values that are used in ARRAY_CONTAINS or ARRAY_CONTAINS_ANY
- * filters. Returns `null` if there are no such filters.
+ * Returns true if this filter is a conjunction of field filters only. Returns false otherwise.
  */
-function targetGetArrayValues(target, fieldIndex) {
-    const segment = fieldIndexGetArraySegment(fieldIndex);
-    if (segment === undefined) {
-        return null;
-    }
-    for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
-        switch (fieldFilter.op) {
-            case "array-contains-any" /* ARRAY_CONTAINS_ANY */:
-                return fieldFilter.value.arrayValue.values || [];
-            case "array-contains" /* ARRAY_CONTAINS */:
-                return [fieldFilter.value];
-            // Remaining filters are not array filters.
-        }
-    }
-    return null;
+function compositeFilterIsFlatConjunction(compositeFilter) {
+    return (compositeFilterIsFlat(compositeFilter) &&
+        compositeFilterIsConjunction(compositeFilter));
 }
 /**
- * Returns the list of values that are used in != or NOT_IN filters. Returns
- * `null` if there are no such filters.
+ * Returns true if this filter does not contain any composite filters. Returns false otherwise.
  */
-function targetGetNotInValues(target, fieldIndex) {
-    const values = new Map();
-    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
-        for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
-            switch (fieldFilter.op) {
-                case "==" /* EQUAL */:
-                case "in" /* IN */:
-                    // Encode equality prefix, which is encoded in the index value before
-                    // the inequality (e.g. `a == 'a' && b != 'b'` is encoded to
-                    // `value != 'ab'`).
-                    values.set(segment.fieldPath.canonicalString(), fieldFilter.value);
-                    break;
-                case "not-in" /* NOT_IN */:
-                case "!=" /* NOT_EQUAL */:
-                    // NotIn/NotEqual is always a suffix. There cannot be any remaining
-                    // segments and hence we can return early here.
-                    values.set(segment.fieldPath.canonicalString(), fieldFilter.value);
-                    return Array.from(values.values());
-                // Remaining filters cannot be used as notIn bounds.
-            }
+function compositeFilterIsFlat(compositeFilter) {
+    for (const filter of compositeFilter.filters) {
+        if (filter instanceof CompositeFilter) {
+            return false;
         }
     }
-    return null;
+    return true;
 }
-/**
- * Returns a lower bound of field values that can be used as a starting point to
- * scan the index defined by `fieldIndex`. Returns `MIN_VALUE` if no lower bound
- * exists.
- */
-function targetGetLowerBound(target, fieldIndex) {
-    const values = [];
-    let inclusive = true;
-    // For each segment, retrieve a lower bound if there is a suitable filter or
-    // startAt.
-    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
-        const segmentBound = segment.kind === 0 /* ASCENDING */
-            ? targetGetAscendingBound(target, segment.fieldPath, target.startAt)
-            : targetGetDescendingBound(target, segment.fieldPath, target.startAt);
-        values.push(segmentBound.value);
-        inclusive && (inclusive = segmentBound.inclusive);
+function canonifyFilter(filter) {
+    if (filter instanceof FieldFilter) {
+        // TODO(b/29183165): Technically, this won't be unique if two values have
+        // the same description, such as the int 3 and the string "3". So we should
+        // add the types in here somehow, too.
+        return (filter.field.canonicalString() +
+            filter.op.toString() +
+            canonicalId(filter.value));
+    }
+    else if (compositeFilterIsFlatConjunction(filter)) {
+        // Older SDK versions use an implicit AND operation between their filters.
+        // In the new SDK versions, the developer may use an explicit AND filter.
+        // To stay consistent with the old usages, we add a special case to ensure
+        // the canonical ID for these two are the same. For example:
+        // `col.whereEquals("a", 1).whereEquals("b", 2)` should have the same
+        // canonical ID as `col.where(and(equals("a",1), equals("b",2)))`.
+        return filter.filters.map(filter => canonifyFilter(filter)).join(',');
     }
-    return new Bound(values, inclusive);
-}
-/**
- * Returns an upper bound of field values that can be used as an ending point
- * when scanning the index defined by `fieldIndex`. Returns `MAX_VALUE` if no
- * upper bound exists.
- */
-function targetGetUpperBound(target, fieldIndex) {
-    const values = [];
-    let inclusive = true;
-    // For each segment, retrieve an upper bound if there is a suitable filter or
-    // endAt.
-    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
-        const segmentBound = segment.kind === 0 /* ASCENDING */
-            ? targetGetDescendingBound(target, segment.fieldPath, target.endAt)
-            : targetGetAscendingBound(target, segment.fieldPath, target.endAt);
-        values.push(segmentBound.value);
-        inclusive && (inclusive = segmentBound.inclusive);
+    else {
+        // filter instanceof CompositeFilter
+        const canonicalIdsString = filter.filters
+            .map(filter => canonifyFilter(filter))
+            .join(',');
+        return `${filter.op}(${canonicalIdsString})`;
     }
-    return new Bound(values, inclusive);
 }
-/**
- * Returns the value to use as the lower bound for ascending index segment at
- * the provided `fieldPath` (or the upper bound for an descending segment).
- */
-function targetGetAscendingBound(target, fieldPath, bound) {
-    let value = MIN_VALUE;
-    let inclusive = true;
-    // Process all filters to find a value for the current field segment
-    for (const fieldFilter of targetGetFieldFiltersForPath(target, fieldPath)) {
-        let filterValue = MIN_VALUE;
-        let filterInclusive = true;
-        switch (fieldFilter.op) {
-            case "<" /* LESS_THAN */:
-            case "<=" /* LESS_THAN_OR_EQUAL */:
-                filterValue = valuesGetLowerBound(fieldFilter.value);
-                break;
-            case "==" /* EQUAL */:
-            case "in" /* IN */:
-            case ">=" /* GREATER_THAN_OR_EQUAL */:
-                filterValue = fieldFilter.value;
-                break;
-            case ">" /* GREATER_THAN */:
-                filterValue = fieldFilter.value;
-                filterInclusive = false;
-                break;
-            case "!=" /* NOT_EQUAL */:
-            case "not-in" /* NOT_IN */:
-                filterValue = MIN_VALUE;
-                break;
-            // Remaining filters cannot be used as lower bounds.
-        }
-        if (lowerBoundCompare({ value, inclusive }, { value: filterValue, inclusive: filterInclusive }) < 0) {
-            value = filterValue;
-            inclusive = filterInclusive;
-        }
-    }
-    // If there is an additional bound, compare the values against the existing
-    // range to see if we can narrow the scope.
-    if (bound !== null) {
-        for (let i = 0; i < target.orderBy.length; ++i) {
-            const orderBy = target.orderBy[i];
-            if (orderBy.field.isEqual(fieldPath)) {
-                const cursorValue = bound.position[i];
-                if (lowerBoundCompare({ value, inclusive }, { value: cursorValue, inclusive: bound.inclusive }) < 0) {
-                    value = cursorValue;
-                    inclusive = bound.inclusive;
-                }
-                break;
-            }
-        }
+function filterEquals(f1, f2) {
+    if (f1 instanceof FieldFilter) {
+        return fieldFilterEquals(f1, f2);
     }
-    return { value, inclusive };
-}
-/**
- * Returns the value to use as the upper bound for ascending index segment at
- * the provided `fieldPath` (or the lower bound for a descending segment).
- */
-function targetGetDescendingBound(target, fieldPath, bound) {
-    let value = MAX_VALUE;
-    let inclusive = true;
-    // Process all filters to find a value for the current field segment
-    for (const fieldFilter of targetGetFieldFiltersForPath(target, fieldPath)) {
-        let filterValue = MAX_VALUE;
-        let filterInclusive = true;
-        switch (fieldFilter.op) {
-            case ">=" /* GREATER_THAN_OR_EQUAL */:
-            case ">" /* GREATER_THAN */:
-                filterValue = valuesGetUpperBound(fieldFilter.value);
-                filterInclusive = false;
-                break;
-            case "==" /* EQUAL */:
-            case "in" /* IN */:
-            case "<=" /* LESS_THAN_OR_EQUAL */:
-                filterValue = fieldFilter.value;
-                break;
-            case "<" /* LESS_THAN */:
-                filterValue = fieldFilter.value;
-                filterInclusive = false;
-                break;
-            case "!=" /* NOT_EQUAL */:
-            case "not-in" /* NOT_IN */:
-                filterValue = MAX_VALUE;
-                break;
-            // Remaining filters cannot be used as upper bounds.
-        }
-        if (upperBoundCompare({ value, inclusive }, { value: filterValue, inclusive: filterInclusive }) > 0) {
-            value = filterValue;
-            inclusive = filterInclusive;
-        }
+    else if (f1 instanceof CompositeFilter) {
+        return compositeFilterEquals(f1, f2);
     }
-    // If there is an additional bound, compare the values against the existing
-    // range to see if we can narrow the scope.
-    if (bound !== null) {
-        for (let i = 0; i < target.orderBy.length; ++i) {
-            const orderBy = target.orderBy[i];
-            if (orderBy.field.isEqual(fieldPath)) {
-                const cursorValue = bound.position[i];
-                if (upperBoundCompare({ value, inclusive }, { value: cursorValue, inclusive: bound.inclusive }) > 0) {
-                    value = cursorValue;
-                    inclusive = bound.inclusive;
-                }
-                break;
-            }
-        }
+    else {
+        fail();
     }
-    return { value, inclusive };
 }
-/** Returns the number of segments of a perfect index for this target. */
-function targetGetSegmentCount(target) {
-    let fields = new SortedSet(FieldPath$1.comparator);
-    let hasArraySegment = false;
-    for (const filter of target.filters) {
-        // TODO(orquery): Use the flattened filters here
-        const fieldFilter = filter;
-        // __name__ is not an explicit segment of any index, so we don't need to
-        // count it.
-        if (fieldFilter.field.isKeyField()) {
-            continue;
-        }
-        // ARRAY_CONTAINS or ARRAY_CONTAINS_ANY filters must be counted separately.
-        // For instance, it is possible to have an index for "a ARRAY a ASC". Even
-        // though these are on the same field, they should be counted as two
-        // separate segments in an index.
-        if (fieldFilter.op === "array-contains" /* ARRAY_CONTAINS */ ||
-            fieldFilter.op === "array-contains-any" /* ARRAY_CONTAINS_ANY */) {
-            hasArraySegment = true;
-        }
-        else {
-            fields = fields.add(fieldFilter.field);
-        }
-    }
-    for (const orderBy of target.orderBy) {
-        // __name__ is not an explicit segment of any index, so we don't need to
-        // count it.
-        if (!orderBy.field.isKeyField()) {
-            fields = fields.add(orderBy.field);
-        }
+function fieldFilterEquals(f1, f2) {
+    return (f2 instanceof FieldFilter &&
+        f1.op === f2.op &&
+        f1.field.isEqual(f2.field) &&
+        valueEquals(f1.value, f2.value));
+}
+function compositeFilterEquals(f1, f2) {
+    if (f2 instanceof CompositeFilter &&
+        f1.op === f2.op &&
+        f1.filters.length === f2.filters.length) {
+        const subFiltersMatch = f1.filters.reduce((result, f1Filter, index) => result && filterEquals(f1Filter, f2.filters[index]), true);
+        return subFiltersMatch;
     }
-    return fields.size + (hasArraySegment ? 1 : 0);
+    return false;
 }
-class Filter {
+/**
+ * Returns a new composite filter that contains all filter from
+ * `compositeFilter` plus all the given filters in `otherFilters`.
+ */
+function compositeFilterWithAddedFilters(compositeFilter, otherFilters) {
+    const mergedFilters = compositeFilter.filters.concat(otherFilters);
+    return CompositeFilter.create(mergedFilters, compositeFilter.op);
 }
-class FieldFilter extends Filter {
-    constructor(field, op, value) {
-        super();
-        this.field = field;
-        this.op = op;
-        this.value = value;
-    }
-    /**
-     * Creates a filter based on the provided arguments.
-     */
-    static create(field, op, value) {
-        if (field.isKeyField()) {
-            if (op === "in" /* IN */ || op === "not-in" /* NOT_IN */) {
-                return this.createKeyFieldInFilter(field, op, value);
-            }
-            else {
-                return new KeyFieldFilter(field, op, value);
-            }
-        }
-        else if (op === "array-contains" /* ARRAY_CONTAINS */) {
-            return new ArrayContainsFilter(field, value);
-        }
-        else if (op === "in" /* IN */) {
-            return new InFilter(field, value);
-        }
-        else if (op === "not-in" /* NOT_IN */) {
-            return new NotInFilter(field, value);
-        }
-        else if (op === "array-contains-any" /* ARRAY_CONTAINS_ANY */) {
-            return new ArrayContainsAnyFilter(field, value);
-        }
-        else {
-            return new FieldFilter(field, op, value);
-        }
-    }
-    static createKeyFieldInFilter(field, op, value) {
-        return op === "in" /* IN */
-            ? new KeyFieldInFilter(field, value)
-            : new KeyFieldNotInFilter(field, value);
-    }
-    matches(doc) {
-        const other = doc.data.field(this.field);
-        // Types do not have to match in NOT_EQUAL filters.
-        if (this.op === "!=" /* NOT_EQUAL */) {
-            return (other !== null &&
-                this.matchesComparison(valueCompare(other, this.value)));
-        }
-        // Only compare types with matching backend order (such as double and int).
-        return (other !== null &&
-            typeOrder(this.value) === typeOrder(other) &&
-            this.matchesComparison(valueCompare(other, this.value)));
+/** Returns a debug description for `filter`. */
+function stringifyFilter(filter) {
+    if (filter instanceof FieldFilter) {
+        return stringifyFieldFilter(filter);
     }
-    matchesComparison(comparison) {
-        switch (this.op) {
-            case "<" /* LESS_THAN */:
-                return comparison < 0;
-            case "<=" /* LESS_THAN_OR_EQUAL */:
-                return comparison <= 0;
-            case "==" /* EQUAL */:
-                return comparison === 0;
-            case "!=" /* NOT_EQUAL */:
-                return comparison !== 0;
-            case ">" /* GREATER_THAN */:
-                return comparison > 0;
-            case ">=" /* GREATER_THAN_OR_EQUAL */:
-                return comparison >= 0;
-            default:
-                return fail();
-        }
+    else if (filter instanceof CompositeFilter) {
+        return stringifyCompositeFilter(filter);
     }
-    isInequality() {
-        return ([
-            "<" /* LESS_THAN */,
-            "<=" /* LESS_THAN_OR_EQUAL */,
-            ">" /* GREATER_THAN */,
-            ">=" /* GREATER_THAN_OR_EQUAL */,
-            "!=" /* NOT_EQUAL */,
-            "not-in" /* NOT_IN */
-        ].indexOf(this.op) >= 0);
+    else {
+        return 'Filter';
     }
 }
-function canonifyFilter(filter) {
-    // TODO(b/29183165): Technically, this won't be unique if two values have
-    // the same description, such as the int 3 and the string "3". So we should
-    // add the types in here somehow, too.
-    return (filter.field.canonicalString() +
-        filter.op.toString() +
-        canonicalId(filter.value));
-}
-function filterEquals(f1, f2) {
-    return (f1.op === f2.op &&
-        f1.field.isEqual(f2.field) &&
-        valueEquals(f1.value, f2.value));
+function stringifyCompositeFilter(filter) {
+    return (filter.op.toString() +
+        ` {` +
+        filter.getFilters().map(stringifyFilter).join(' ,') +
+        '}');
 }
-/** Returns a debug description for `filter`. */
-function stringifyFilter(filter) {
+function stringifyFieldFilter(filter) {
     return `${filter.field.canonicalString()} ${filter.op} ${canonicalId(filter.value)}`;
 }
 /** Filter that matches on key fields (i.e. '__name__'). */
@@ -5780,8 +5704,8 @@ class KeyFieldFilter extends FieldFilter {
 /** Filter that matches on key fields within an array. */
 class KeyFieldInFilter extends FieldFilter {
     constructor(field, value) {
-        super(field, "in" /* IN */, value);
-        this.keys = extractDocumentKeysFromArrayValue("in" /* IN */, value);
+        super(field, "in" /* Operator.IN */, value);
+        this.keys = extractDocumentKeysFromArrayValue("in" /* Operator.IN */, value);
     }
     matches(doc) {
         return this.keys.some(key => key.isEqual(doc.key));
@@ -5790,8 +5714,8 @@ class KeyFieldInFilter extends FieldFilter {
 /** Filter that matches on key fields not present within an array. */
 class KeyFieldNotInFilter extends FieldFilter {
     constructor(field, value) {
-        super(field, "not-in" /* NOT_IN */, value);
-        this.keys = extractDocumentKeysFromArrayValue("not-in" /* NOT_IN */, value);
+        super(field, "not-in" /* Operator.NOT_IN */, value);
+        this.keys = extractDocumentKeysFromArrayValue("not-in" /* Operator.NOT_IN */, value);
     }
     matches(doc) {
         return !this.keys.some(key => key.isEqual(doc.key));
@@ -5806,7 +5730,7 @@ function extractDocumentKeysFromArrayValue(op, value) {
 /** A Filter that implements the array-contains operator. */
 class ArrayContainsFilter extends FieldFilter {
     constructor(field, value) {
-        super(field, "array-contains" /* ARRAY_CONTAINS */, value);
+        super(field, "array-contains" /* Operator.ARRAY_CONTAINS */, value);
     }
     matches(doc) {
         const other = doc.data.field(this.field);
@@ -5816,7 +5740,7 @@ class ArrayContainsFilter extends FieldFilter {
 /** A Filter that implements the IN operator. */
 class InFilter extends FieldFilter {
     constructor(field, value) {
-        super(field, "in" /* IN */, value);
+        super(field, "in" /* Operator.IN */, value);
     }
     matches(doc) {
         const other = doc.data.field(this.field);
@@ -5826,7 +5750,7 @@ class InFilter extends FieldFilter {
 /** A Filter that implements the not-in operator. */
 class NotInFilter extends FieldFilter {
     constructor(field, value) {
-        super(field, "not-in" /* NOT_IN */, value);
+        super(field, "not-in" /* Operator.NOT_IN */, value);
     }
     matches(doc) {
         if (arrayValueContains(this.value.arrayValue, { nullValue: 'NULL_VALUE' })) {
@@ -5839,7 +5763,7 @@ class NotInFilter extends FieldFilter {
 /** A Filter that implements the array-contains-any operator. */
 class ArrayContainsAnyFilter extends FieldFilter {
     constructor(field, value) {
-        super(field, "array-contains-any" /* ARRAY_CONTAINS_ANY */, value);
+        super(field, "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */, value);
     }
     matches(doc) {
         const other = doc.data.field(this.field);
@@ -5848,32 +5772,29 @@ class ArrayContainsAnyFilter extends FieldFilter {
         }
         return other.arrayValue.values.some(val => arrayValueContains(this.value.arrayValue, val));
     }
-}
-/**
- * Represents a bound of a query.
+}
+
+/**
+ * @license
+ * Copyright 2022 Google LLC
  *
- * The bound is specified with the given components representing a position and
- * whether it's just before or just after the position (relative to whatever the
- * query order is).
+ * 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
  *
- * The position represents a logical index position for a query. It's a prefix
- * of values for the (potentially implicit) order by clauses of a query.
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- * Bound provides a function to determine whether a document comes before or
- * after a bound. This is influenced by whether the position is just before or
- * just after the provided values.
+ * 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.
  */
-class Bound {
-    constructor(position, inclusive) {
-        this.position = position;
-        this.inclusive = inclusive;
-    }
-}
 /**
  * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
  */
 class OrderBy {
-    constructor(field, dir = "asc" /* ASCENDING */) {
+    constructor(field, dir = "asc" /* Direction.ASCENDING */) {
         this.field = field;
         this.dir = dir;
     }
@@ -5887,63 +5808,375 @@ function stringifyOrderBy(orderBy) {
 }
 function orderByEquals(left, right) {
     return left.dir === right.dir && left.field.isEqual(right.field);
+}
+
+/**
+ * @license
+ * Copyright 2019 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.
+ */
+// Visible for testing
+class TargetImpl {
+    constructor(path, collectionGroup = null, orderBy = [], filters = [], limit = null, startAt = null, endAt = null) {
+        this.path = path;
+        this.collectionGroup = collectionGroup;
+        this.orderBy = orderBy;
+        this.filters = filters;
+        this.limit = limit;
+        this.startAt = startAt;
+        this.endAt = endAt;
+        this.memoizedCanonicalId = null;
+    }
 }
-function boundCompareToDocument(bound, orderBy, doc) {
-    let comparison = 0;
-    for (let i = 0; i < bound.position.length; i++) {
-        const orderByComponent = orderBy[i];
-        const component = bound.position[i];
-        if (orderByComponent.field.isKeyField()) {
-            comparison = DocumentKey.comparator(DocumentKey.fromName(component.referenceValue), doc.key);
+/**
+ * Initializes a Target with a path and optional additional query constraints.
+ * Path must currently be empty if this is a collection group query.
+ *
+ * NOTE: you should always construct `Target` from `Query.toTarget` instead of
+ * using this factory method, because `Query` provides an implicit `orderBy`
+ * property.
+ */
+function newTarget(path, collectionGroup = null, orderBy = [], filters = [], limit = null, startAt = null, endAt = null) {
+    return new TargetImpl(path, collectionGroup, orderBy, filters, limit, startAt, endAt);
+}
+function canonifyTarget(target) {
+    const targetImpl = debugCast(target);
+    if (targetImpl.memoizedCanonicalId === null) {
+        let str = targetImpl.path.canonicalString();
+        if (targetImpl.collectionGroup !== null) {
+            str += '|cg:' + targetImpl.collectionGroup;
         }
-        else {
-            const docValue = doc.data.field(orderByComponent.field);
-            comparison = valueCompare(component, docValue);
+        str += '|f:';
+        str += targetImpl.filters.map(f => canonifyFilter(f)).join(',');
+        str += '|ob:';
+        str += targetImpl.orderBy.map(o => canonifyOrderBy(o)).join(',');
+        if (!isNullOrUndefined(targetImpl.limit)) {
+            str += '|l:';
+            str += targetImpl.limit;
         }
-        if (orderByComponent.dir === "desc" /* DESCENDING */) {
-            comparison = comparison * -1;
+        if (targetImpl.startAt) {
+            str += '|lb:';
+            str += targetImpl.startAt.inclusive ? 'b:' : 'a:';
+            str += targetImpl.startAt.position.map(p => canonicalId(p)).join(',');
         }
-        if (comparison !== 0) {
-            break;
+        if (targetImpl.endAt) {
+            str += '|ub:';
+            str += targetImpl.endAt.inclusive ? 'a:' : 'b:';
+            str += targetImpl.endAt.position.map(p => canonicalId(p)).join(',');
         }
+        targetImpl.memoizedCanonicalId = str;
     }
-    return comparison;
+    return targetImpl.memoizedCanonicalId;
+}
+function stringifyTarget(target) {
+    let str = target.path.canonicalString();
+    if (target.collectionGroup !== null) {
+        str += ' collectionGroup=' + target.collectionGroup;
+    }
+    if (target.filters.length > 0) {
+        str += `, filters: [${target.filters
+            .map(f => stringifyFilter(f))
+            .join(', ')}]`;
+    }
+    if (!isNullOrUndefined(target.limit)) {
+        str += ', limit: ' + target.limit;
+    }
+    if (target.orderBy.length > 0) {
+        str += `, orderBy: [${target.orderBy
+            .map(o => stringifyOrderBy(o))
+            .join(', ')}]`;
+    }
+    if (target.startAt) {
+        str += ', startAt: ';
+        str += target.startAt.inclusive ? 'b:' : 'a:';
+        str += target.startAt.position.map(p => canonicalId(p)).join(',');
+    }
+    if (target.endAt) {
+        str += ', endAt: ';
+        str += target.endAt.inclusive ? 'a:' : 'b:';
+        str += target.endAt.position.map(p => canonicalId(p)).join(',');
+    }
+    return `Target(${str})`;
+}
+function targetEquals(left, right) {
+    if (left.limit !== right.limit) {
+        return false;
+    }
+    if (left.orderBy.length !== right.orderBy.length) {
+        return false;
+    }
+    for (let i = 0; i < left.orderBy.length; i++) {
+        if (!orderByEquals(left.orderBy[i], right.orderBy[i])) {
+            return false;
+        }
+    }
+    if (left.filters.length !== right.filters.length) {
+        return false;
+    }
+    for (let i = 0; i < left.filters.length; i++) {
+        if (!filterEquals(left.filters[i], right.filters[i])) {
+            return false;
+        }
+    }
+    if (left.collectionGroup !== right.collectionGroup) {
+        return false;
+    }
+    if (!left.path.isEqual(right.path)) {
+        return false;
+    }
+    if (!boundEquals(left.startAt, right.startAt)) {
+        return false;
+    }
+    return boundEquals(left.endAt, right.endAt);
+}
+function targetIsDocumentTarget(target) {
+    return (DocumentKey.isDocumentKey(target.path) &&
+        target.collectionGroup === null &&
+        target.filters.length === 0);
+}
+/** Returns the field filters that target the given field path. */
+function targetGetFieldFiltersForPath(target, path) {
+    return target.filters.filter(f => f instanceof FieldFilter && f.field.isEqual(path));
 }
 /**
- * Returns true if a document sorts after a bound using the provided sort
- * order.
+ * Returns the values that are used in ARRAY_CONTAINS or ARRAY_CONTAINS_ANY
+ * filters. Returns `null` if there are no such filters.
  */
-function boundSortsAfterDocument(bound, orderBy, doc) {
-    const comparison = boundCompareToDocument(bound, orderBy, doc);
-    return bound.inclusive ? comparison >= 0 : comparison > 0;
+function targetGetArrayValues(target, fieldIndex) {
+    const segment = fieldIndexGetArraySegment(fieldIndex);
+    if (segment === undefined) {
+        return null;
+    }
+    for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
+        switch (fieldFilter.op) {
+            case "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */:
+                return fieldFilter.value.arrayValue.values || [];
+            case "array-contains" /* Operator.ARRAY_CONTAINS */:
+                return [fieldFilter.value];
+            // Remaining filters are not array filters.
+        }
+    }
+    return null;
 }
 /**
- * Returns true if a document sorts before a bound using the provided sort
- * order.
+ * Returns the list of values that are used in != or NOT_IN filters. Returns
+ * `null` if there are no such filters.
  */
-function boundSortsBeforeDocument(bound, orderBy, doc) {
-    const comparison = boundCompareToDocument(bound, orderBy, doc);
-    return bound.inclusive ? comparison <= 0 : comparison < 0;
+function targetGetNotInValues(target, fieldIndex) {
+    const values = new Map();
+    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
+        for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
+            switch (fieldFilter.op) {
+                case "==" /* Operator.EQUAL */:
+                case "in" /* Operator.IN */:
+                    // Encode equality prefix, which is encoded in the index value before
+                    // the inequality (e.g. `a == 'a' && b != 'b'` is encoded to
+                    // `value != 'ab'`).
+                    values.set(segment.fieldPath.canonicalString(), fieldFilter.value);
+                    break;
+                case "not-in" /* Operator.NOT_IN */:
+                case "!=" /* Operator.NOT_EQUAL */:
+                    // NotIn/NotEqual is always a suffix. There cannot be any remaining
+                    // segments and hence we can return early here.
+                    values.set(segment.fieldPath.canonicalString(), fieldFilter.value);
+                    return Array.from(values.values());
+                // Remaining filters cannot be used as notIn bounds.
+            }
+        }
+    }
+    return null;
 }
-function boundEquals(left, right) {
-    if (left === null) {
-        return right === null;
+/**
+ * Returns a lower bound of field values that can be used as a starting point to
+ * scan the index defined by `fieldIndex`. Returns `MIN_VALUE` if no lower bound
+ * exists.
+ */
+function targetGetLowerBound(target, fieldIndex) {
+    const values = [];
+    let inclusive = true;
+    // For each segment, retrieve a lower bound if there is a suitable filter or
+    // startAt.
+    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
+        const segmentBound = segment.kind === 0 /* IndexKind.ASCENDING */
+            ? targetGetAscendingBound(target, segment.fieldPath, target.startAt)
+            : targetGetDescendingBound(target, segment.fieldPath, target.startAt);
+        values.push(segmentBound.value);
+        inclusive && (inclusive = segmentBound.inclusive);
     }
-    else if (right === null) {
-        return false;
+    return new Bound(values, inclusive);
+}
+/**
+ * Returns an upper bound of field values that can be used as an ending point
+ * when scanning the index defined by `fieldIndex`. Returns `MAX_VALUE` if no
+ * upper bound exists.
+ */
+function targetGetUpperBound(target, fieldIndex) {
+    const values = [];
+    let inclusive = true;
+    // For each segment, retrieve an upper bound if there is a suitable filter or
+    // endAt.
+    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
+        const segmentBound = segment.kind === 0 /* IndexKind.ASCENDING */
+            ? targetGetDescendingBound(target, segment.fieldPath, target.endAt)
+            : targetGetAscendingBound(target, segment.fieldPath, target.endAt);
+        values.push(segmentBound.value);
+        inclusive && (inclusive = segmentBound.inclusive);
+    }
+    return new Bound(values, inclusive);
+}
+/**
+ * Returns the value to use as the lower bound for ascending index segment at
+ * the provided `fieldPath` (or the upper bound for an descending segment).
+ */
+function targetGetAscendingBound(target, fieldPath, bound) {
+    let value = MIN_VALUE;
+    let inclusive = true;
+    // Process all filters to find a value for the current field segment
+    for (const fieldFilter of targetGetFieldFiltersForPath(target, fieldPath)) {
+        let filterValue = MIN_VALUE;
+        let filterInclusive = true;
+        switch (fieldFilter.op) {
+            case "<" /* Operator.LESS_THAN */:
+            case "<=" /* Operator.LESS_THAN_OR_EQUAL */:
+                filterValue = valuesGetLowerBound(fieldFilter.value);
+                break;
+            case "==" /* Operator.EQUAL */:
+            case "in" /* Operator.IN */:
+            case ">=" /* Operator.GREATER_THAN_OR_EQUAL */:
+                filterValue = fieldFilter.value;
+                break;
+            case ">" /* Operator.GREATER_THAN */:
+                filterValue = fieldFilter.value;
+                filterInclusive = false;
+                break;
+            case "!=" /* Operator.NOT_EQUAL */:
+            case "not-in" /* Operator.NOT_IN */:
+                filterValue = MIN_VALUE;
+                break;
+            // Remaining filters cannot be used as lower bounds.
+        }
+        if (lowerBoundCompare({ value, inclusive }, { value: filterValue, inclusive: filterInclusive }) < 0) {
+            value = filterValue;
+            inclusive = filterInclusive;
+        }
+    }
+    // If there is an additional bound, compare the values against the existing
+    // range to see if we can narrow the scope.
+    if (bound !== null) {
+        for (let i = 0; i < target.orderBy.length; ++i) {
+            const orderBy = target.orderBy[i];
+            if (orderBy.field.isEqual(fieldPath)) {
+                const cursorValue = bound.position[i];
+                if (lowerBoundCompare({ value, inclusive }, { value: cursorValue, inclusive: bound.inclusive }) < 0) {
+                    value = cursorValue;
+                    inclusive = bound.inclusive;
+                }
+                break;
+            }
+        }
+    }
+    return { value, inclusive };
+}
+/**
+ * Returns the value to use as the upper bound for ascending index segment at
+ * the provided `fieldPath` (or the lower bound for a descending segment).
+ */
+function targetGetDescendingBound(target, fieldPath, bound) {
+    let value = MAX_VALUE;
+    let inclusive = true;
+    // Process all filters to find a value for the current field segment
+    for (const fieldFilter of targetGetFieldFiltersForPath(target, fieldPath)) {
+        let filterValue = MAX_VALUE;
+        let filterInclusive = true;
+        switch (fieldFilter.op) {
+            case ">=" /* Operator.GREATER_THAN_OR_EQUAL */:
+            case ">" /* Operator.GREATER_THAN */:
+                filterValue = valuesGetUpperBound(fieldFilter.value);
+                filterInclusive = false;
+                break;
+            case "==" /* Operator.EQUAL */:
+            case "in" /* Operator.IN */:
+            case "<=" /* Operator.LESS_THAN_OR_EQUAL */:
+                filterValue = fieldFilter.value;
+                break;
+            case "<" /* Operator.LESS_THAN */:
+                filterValue = fieldFilter.value;
+                filterInclusive = false;
+                break;
+            case "!=" /* Operator.NOT_EQUAL */:
+            case "not-in" /* Operator.NOT_IN */:
+                filterValue = MAX_VALUE;
+                break;
+            // Remaining filters cannot be used as upper bounds.
+        }
+        if (upperBoundCompare({ value, inclusive }, { value: filterValue, inclusive: filterInclusive }) > 0) {
+            value = filterValue;
+            inclusive = filterInclusive;
+        }
+    }
+    // If there is an additional bound, compare the values against the existing
+    // range to see if we can narrow the scope.
+    if (bound !== null) {
+        for (let i = 0; i < target.orderBy.length; ++i) {
+            const orderBy = target.orderBy[i];
+            if (orderBy.field.isEqual(fieldPath)) {
+                const cursorValue = bound.position[i];
+                if (upperBoundCompare({ value, inclusive }, { value: cursorValue, inclusive: bound.inclusive }) > 0) {
+                    value = cursorValue;
+                    inclusive = bound.inclusive;
+                }
+                break;
+            }
+        }
     }
-    if (left.inclusive !== right.inclusive ||
-        left.position.length !== right.position.length) {
-        return false;
+    return { value, inclusive };
+}
+/** Returns the number of segments of a perfect index for this target. */
+function targetGetSegmentCount(target) {
+    let fields = new SortedSet(FieldPath$1.comparator);
+    let hasArraySegment = false;
+    for (const filter of target.filters) {
+        for (const subFilter of filter.getFlattenedFilters()) {
+            // __name__ is not an explicit segment of any index, so we don't need to
+            // count it.
+            if (subFilter.field.isKeyField()) {
+                continue;
+            }
+            // ARRAY_CONTAINS or ARRAY_CONTAINS_ANY filters must be counted separately.
+            // For instance, it is possible to have an index for "a ARRAY a ASC". Even
+            // though these are on the same field, they should be counted as two
+            // separate segments in an index.
+            if (subFilter.op === "array-contains" /* Operator.ARRAY_CONTAINS */ ||
+                subFilter.op === "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */) {
+                hasArraySegment = true;
+            }
+            else {
+                fields = fields.add(subFilter.field);
+            }
+        }
     }
-    for (let i = 0; i < left.position.length; i++) {
-        const leftPosition = left.position[i];
-        const rightPosition = right.position[i];
-        if (!valueEquals(leftPosition, rightPosition)) {
-            return false;
+    for (const orderBy of target.orderBy) {
+        // __name__ is not an explicit segment of any index, so we don't need to
+        // count it.
+        if (!orderBy.field.isKeyField()) {
+            fields = fields.add(orderBy.field);
         }
     }
-    return true;
+    return fields.size + (hasArraySegment ? 1 : 0);
+}
+function targetHasLimit(target) {
+    return target.limit !== null;
 }
 
 /**
@@ -5974,7 +6207,7 @@ class QueryImpl {
      * Initializes a Query with a path and optional additional query constraints.
      * Path must currently be empty if this is a collection group query.
      */
-    constructor(path, collectionGroup = null, explicitOrderBy = [], filters = [], limit = null, limitType = "F" /* First */, startAt = null, endAt = null) {
+    constructor(path, collectionGroup = null, explicitOrderBy = [], filters = [], limit = null, limitType = "F" /* LimitType.First */, startAt = null, endAt = null) {
         this.path = path;
         this.collectionGroup = collectionGroup;
         this.explicitOrderBy = explicitOrderBy;
@@ -6028,20 +6261,9 @@ function getFirstOrderByField(query) {
 }
 function getInequalityFilterField(query) {
     for (const filter of query.filters) {
-        if (filter.isInequality()) {
-            return filter.field;
-        }
-    }
-    return null;
-}
-/**
- * Checks if any of the provided Operators are included in the query and
- * returns the first one that is, or null if none are.
- */
-function findFilterOperator(query, operators) {
-    for (const filter of query.filters) {
-        if (operators.indexOf(filter.op) >= 0) {
-            return filter.op;
+        const result = filter.getFirstInequalityField();
+        if (result !== null) {
+            return result;
         }
     }
     return null;
@@ -6087,7 +6309,7 @@ function queryOrderBy(query) {
             if (!inequalityField.isKeyField()) {
                 queryImpl.memoizedOrderBy.push(new OrderBy(inequalityField));
             }
-            queryImpl.memoizedOrderBy.push(new OrderBy(FieldPath$1.keyField(), "asc" /* ASCENDING */));
+            queryImpl.memoizedOrderBy.push(new OrderBy(FieldPath$1.keyField(), "asc" /* Direction.ASCENDING */));
         }
         else {
             let foundKeyOrdering = false;
@@ -6103,7 +6325,7 @@ function queryOrderBy(query) {
                 const lastDirection = queryImpl.explicitOrderBy.length > 0
                     ? queryImpl.explicitOrderBy[queryImpl.explicitOrderBy.length - 1]
                         .dir
-                    : "asc" /* ASCENDING */;
+                    : "asc" /* Direction.ASCENDING */;
                 queryImpl.memoizedOrderBy.push(new OrderBy(FieldPath$1.keyField(), lastDirection));
             }
         }
@@ -6116,16 +6338,16 @@ function queryOrderBy(query) {
 function queryToTarget(query) {
     const queryImpl = debugCast(query);
     if (!queryImpl.memoizedTarget) {
-        if (queryImpl.limitType === "F" /* First */) {
+        if (queryImpl.limitType === "F" /* LimitType.First */) {
             queryImpl.memoizedTarget = newTarget(queryImpl.path, queryImpl.collectionGroup, queryOrderBy(queryImpl), queryImpl.filters, queryImpl.limit, queryImpl.startAt, queryImpl.endAt);
         }
         else {
             // Flip the orderBy directions since we want the last results
             const orderBys = [];
             for (const orderBy of queryOrderBy(queryImpl)) {
-                const dir = orderBy.dir === "desc" /* DESCENDING */
-                    ? "asc" /* ASCENDING */
-                    : "desc" /* DESCENDING */;
+                const dir = orderBy.dir === "desc" /* Direction.DESCENDING */
+                    ? "asc" /* Direction.ASCENDING */
+                    : "desc" /* Direction.DESCENDING */;
                 orderBys.push(new OrderBy(orderBy.field, dir));
             }
             // We need to swap the cursors to match the now-flipped query ordering.
@@ -6142,6 +6364,8 @@ function queryToTarget(query) {
     return queryImpl.memoizedTarget;
 }
 function queryWithAddedFilter(query, filter) {
+    filter.getFirstInequalityField();
+    getInequalityFilterField(query);
     const newFilters = query.filters.concat([filter]);
     return new QueryImpl(query.path, query.collectionGroup, query.explicitOrderBy.slice(), newFilters, query.limit, query.limitType, query.startAt, query.endAt);
 }
@@ -6202,7 +6426,13 @@ function queryMatchesPathAndCollectionGroup(query, doc) {
  * in the results.
  */
 function queryMatchesOrderBy(query, doc) {
-    for (const orderBy of query.explicitOrderBy) {
+    // We must use `queryOrderBy()` to get the list of all orderBys (both implicit and explicit).
+    // Note that for OR queries, orderBy applies to all disjunction terms and implicit orderBys must
+    // be taken into account. For example, the query "a > 1 || b==1" has an implicit "orderBy a" due
+    // to the inequality, and is evaluated as "a > 1 orderBy a || b==1 orderBy a".
+    // A document with content of {b:1} matches the filters, but does not match the orderBy because
+    // it's missing the field 'a'.
+    for (const orderBy of queryOrderBy(query)) {
         // order by key always matches
         if (!orderBy.field.isKeyField() && doc.data.field(orderBy.field) === null) {
             return false;
@@ -6264,9 +6494,9 @@ function compareDocs(orderBy, d1, d2) {
         ? DocumentKey.comparator(d1.key, d2.key)
         : compareDocumentsByField(orderBy.field, d1, d2);
     switch (orderBy.dir) {
-        case "asc" /* ASCENDING */:
+        case "asc" /* Direction.ASCENDING */:
             return comparison;
-        case "desc" /* DESCENDING */:
+        case "desc" /* Direction.DESCENDING */:
             return -1 * comparison;
         default:
             return fail();
@@ -6952,10 +7182,10 @@ function mutationEquals(left, right) {
     if (!fieldTransformsAreEqual(left.fieldTransforms, right.fieldTransforms)) {
         return false;
     }
-    if (left.type === 0 /* Set */) {
+    if (left.type === 0 /* MutationType.Set */) {
         return left.value.isEqual(right.value);
     }
-    if (left.type === 1 /* Patch */) {
+    if (left.type === 1 /* MutationType.Patch */) {
         return (left.data.isEqual(right.data) &&
             left.fieldMask.isEqual(right.fieldMask));
     }
@@ -6972,7 +7202,7 @@ class SetMutation extends Mutation {
         this.value = value;
         this.precondition = precondition;
         this.fieldTransforms = fieldTransforms;
-        this.type = 0 /* Set */;
+        this.type = 0 /* MutationType.Set */;
     }
     getFieldMask() {
         return null;
@@ -7024,7 +7254,7 @@ class PatchMutation extends Mutation {
         this.fieldMask = fieldMask;
         this.precondition = precondition;
         this.fieldTransforms = fieldTransforms;
-        this.type = 1 /* Patch */;
+        this.type = 1 /* MutationType.Patch */;
     }
     getFieldMask() {
         return this.fieldMask;
@@ -7126,7 +7356,7 @@ class DeleteMutation extends Mutation {
         super();
         this.key = key;
         this.precondition = precondition;
-        this.type = 2 /* Delete */;
+        this.type = 2 /* MutationType.Delete */;
         this.fieldTransforms = [];
     }
     getFieldMask() {
@@ -7160,7 +7390,7 @@ class VerifyMutation extends Mutation {
         super();
         this.key = key;
         this.precondition = precondition;
-        this.type = 3 /* Verify */;
+        this.type = 3 /* MutationType.Verify */;
         this.fieldTransforms = [];
     }
     getFieldMask() {
@@ -7789,13 +8019,13 @@ class TargetState {
         let removedDocuments = documentKeySet();
         this.documentChanges.forEach((key, changeType) => {
             switch (changeType) {
-                case 0 /* Added */:
+                case 0 /* ChangeType.Added */:
                     addedDocuments = addedDocuments.add(key);
                     break;
-                case 2 /* Modified */:
+                case 2 /* ChangeType.Modified */:
                     modifiedDocuments = modifiedDocuments.add(key);
                     break;
-                case 1 /* Removed */:
+                case 1 /* ChangeType.Removed */:
                     removedDocuments = removedDocuments.add(key);
                     break;
                 default:
@@ -7871,12 +8101,12 @@ class WatchChangeAggregator {
         this.forEachTarget(targetChange, targetId => {
             const targetState = this.ensureTargetState(targetId);
             switch (targetChange.state) {
-                case 0 /* NoChange */:
+                case 0 /* WatchTargetChangeState.NoChange */:
                     if (this.isActiveTarget(targetId)) {
                         targetState.updateResumeToken(targetChange.resumeToken);
                     }
                     break;
-                case 1 /* Added */:
+                case 1 /* WatchTargetChangeState.Added */:
                     // We need to decrement the number of pending acks needed from watch
                     // for this targetId.
                     targetState.recordTargetResponse();
@@ -7888,7 +8118,7 @@ class WatchChangeAggregator {
                     }
                     targetState.updateResumeToken(targetChange.resumeToken);
                     break;
-                case 2 /* Removed */:
+                case 2 /* WatchTargetChangeState.Removed */:
                     // We need to keep track of removed targets to we can post-filter and
                     // remove any target changes.
                     // We need to decrement the number of pending acks needed from watch
@@ -7898,13 +8128,13 @@ class WatchChangeAggregator {
                         this.removeTarget(targetId);
                     }
                     break;
-                case 3 /* Current */:
+                case 3 /* WatchTargetChangeState.Current */:
                     if (this.isActiveTarget(targetId)) {
                         targetState.markCurrent();
                         targetState.updateResumeToken(targetChange.resumeToken);
                     }
                     break;
-                case 4 /* Reset */:
+                case 4 /* WatchTargetChangeState.Reset */:
                     if (this.isActiveTarget(targetId)) {
                         // Reset the target and synthesizes removes for all existing
                         // documents. The backend will re-add any documents that still
@@ -8014,7 +8244,7 @@ class WatchChangeAggregator {
             targets.forEachWhile(targetId => {
                 const targetData = this.targetDataForActiveTarget(targetId);
                 if (targetData &&
-                    targetData.purpose !== 2 /* LimboResolution */) {
+                    targetData.purpose !== 2 /* TargetPurpose.LimboResolution */) {
                     isOnlyLimboTarget = false;
                     return false;
                 }
@@ -8041,8 +8271,8 @@ class WatchChangeAggregator {
             return;
         }
         const changeType = this.targetContainsDocument(targetId, document.key)
-            ? 2 /* Modified */
-            : 0 /* Added */;
+            ? 2 /* ChangeType.Modified */
+            : 0 /* ChangeType.Added */;
         const targetState = this.ensureTargetState(targetId);
         targetState.addDocumentChange(document.key, changeType);
         this.pendingDocumentUpdates = this.pendingDocumentUpdates.insert(document.key, document);
@@ -8063,7 +8293,7 @@ class WatchChangeAggregator {
         }
         const targetState = this.ensureTargetState(targetId);
         if (this.targetContainsDocument(targetId, key)) {
-            targetState.addDocumentChange(key, 1 /* Removed */);
+            targetState.addDocumentChange(key, 1 /* ChangeType.Removed */);
         }
         else {
             // The document may have entered and left the target before we raised a
@@ -8188,22 +8418,28 @@ function snapshotChangesMap() {
  */
 const DIRECTIONS = (() => {
     const dirs = {};
-    dirs["asc" /* ASCENDING */] = 'ASCENDING';
-    dirs["desc" /* DESCENDING */] = 'DESCENDING';
+    dirs["asc" /* Direction.ASCENDING */] = 'ASCENDING';
+    dirs["desc" /* Direction.DESCENDING */] = 'DESCENDING';
     return dirs;
 })();
 const OPERATORS = (() => {
     const ops = {};
-    ops["<" /* LESS_THAN */] = 'LESS_THAN';
-    ops["<=" /* LESS_THAN_OR_EQUAL */] = 'LESS_THAN_OR_EQUAL';
-    ops[">" /* GREATER_THAN */] = 'GREATER_THAN';
-    ops[">=" /* GREATER_THAN_OR_EQUAL */] = 'GREATER_THAN_OR_EQUAL';
-    ops["==" /* EQUAL */] = 'EQUAL';
-    ops["!=" /* NOT_EQUAL */] = 'NOT_EQUAL';
-    ops["array-contains" /* ARRAY_CONTAINS */] = 'ARRAY_CONTAINS';
-    ops["in" /* IN */] = 'IN';
-    ops["not-in" /* NOT_IN */] = 'NOT_IN';
-    ops["array-contains-any" /* ARRAY_CONTAINS_ANY */] = 'ARRAY_CONTAINS_ANY';
+    ops["<" /* Operator.LESS_THAN */] = 'LESS_THAN';
+    ops["<=" /* Operator.LESS_THAN_OR_EQUAL */] = 'LESS_THAN_OR_EQUAL';
+    ops[">" /* Operator.GREATER_THAN */] = 'GREATER_THAN';
+    ops[">=" /* Operator.GREATER_THAN_OR_EQUAL */] = 'GREATER_THAN_OR_EQUAL';
+    ops["==" /* Operator.EQUAL */] = 'EQUAL';
+    ops["!=" /* Operator.NOT_EQUAL */] = 'NOT_EQUAL';
+    ops["array-contains" /* Operator.ARRAY_CONTAINS */] = 'ARRAY_CONTAINS';
+    ops["in" /* Operator.IN */] = 'IN';
+    ops["not-in" /* Operator.NOT_IN */] = 'NOT_IN';
+    ops["array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */] = 'ARRAY_CONTAINS_ANY';
+    return ops;
+})();
+const COMPOSITE_OPERATORS = (() => {
+    const ops = {};
+    ops["and" /* CompositeOperator.AND */] = 'AND';
+    ops["or" /* CompositeOperator.OR */] = 'OR';
     return ops;
 })();
 function assertPresent(value, description) {
@@ -8397,14 +8633,21 @@ function toDocument(serializer, document) {
     return {
         name: toName(serializer, document.key),
         fields: document.data.value.mapValue.fields,
-        updateTime: toTimestamp(serializer, document.version.toTimestamp())
+        updateTime: toTimestamp(serializer, document.version.toTimestamp()),
+        createTime: toTimestamp(serializer, document.createTime.toTimestamp())
     };
 }
 function fromDocument(serializer, document, hasCommittedMutations) {
     const key = fromName(serializer, document.name);
     const version = fromVersion(document.updateTime);
+    // If we read a document from persistence that is missing createTime, it's due
+    // to older SDK versions not storing this information. In such cases, we'll
+    // set the createTime to zero. This can be removed in the long term.
+    const createTime = document.createTime
+        ? fromVersion(document.createTime)
+        : SnapshotVersion.min();
     const data = new ObjectValue({ mapValue: { fields: document.fields } });
-    const result = MutableDocument.newFoundDocument(key, version, data);
+    const result = MutableDocument.newFoundDocument(key, version, createTime, data);
     if (hasCommittedMutations) {
         result.setHasCommittedMutations();
     }
@@ -8416,8 +8659,11 @@ function fromFound(serializer, doc) {
     assertPresent(doc.found.updateTime);
     const key = fromName(serializer, doc.found.name);
     const version = fromVersion(doc.found.updateTime);
+    const createTime = doc.found.createTime
+        ? fromVersion(doc.found.createTime)
+        : SnapshotVersion.min();
     const data = new ObjectValue({ mapValue: { fields: doc.found.fields } });
-    return MutableDocument.newFoundDocument(key, version, data);
+    return MutableDocument.newFoundDocument(key, version, createTime, data);
 }
 function fromMissing(serializer, result) {
     hardAssert(!!result.missing);
@@ -8456,10 +8702,13 @@ function fromWatchChange(serializer, change) {
         assertPresent(entityChange.document.updateTime);
         const key = fromName(serializer, entityChange.document.name);
         const version = fromVersion(entityChange.document.updateTime);
+        const createTime = entityChange.document.createTime
+            ? fromVersion(entityChange.document.createTime)
+            : SnapshotVersion.min();
         const data = new ObjectValue({
             mapValue: { fields: entityChange.document.fields }
         });
-        const doc = MutableDocument.newFoundDocument(key, version, data);
+        const doc = MutableDocument.newFoundDocument(key, version, createTime, data);
         const updatedTargetIds = entityChange.targetIds || [];
         const removedTargetIds = entityChange.removedTargetIds || [];
         watchChange = new DocumentWatchChange(updatedTargetIds, removedTargetIds, doc.key, doc);
@@ -8501,19 +8750,19 @@ function fromWatchChange(serializer, change) {
 }
 function fromWatchTargetChangeState(state) {
     if (state === 'NO_CHANGE') {
-        return 0 /* NoChange */;
+        return 0 /* WatchTargetChangeState.NoChange */;
     }
     else if (state === 'ADD') {
-        return 1 /* Added */;
+        return 1 /* WatchTargetChangeState.Added */;
     }
     else if (state === 'REMOVE') {
-        return 2 /* Removed */;
+        return 2 /* WatchTargetChangeState.Removed */;
     }
     else if (state === 'CURRENT') {
-        return 3 /* Current */;
+        return 3 /* WatchTargetChangeState.Current */;
     }
     else if (state === 'RESET') {
-        return 4 /* Reset */;
+        return 4 /* WatchTargetChangeState.Reset */;
     }
     else {
         return fail();
@@ -8731,7 +8980,7 @@ function toQueryTarget(serializer, target) {
         result.parent = toQueryPath(serializer, path.popLast());
         result.structuredQuery.from = [{ collectionId: path.lastSegment() }];
     }
-    const where = toFilter(target.filters);
+    const where = toFilters(target.filters);
     if (where) {
         result.structuredQuery.where = where;
     }
@@ -8783,7 +9032,7 @@ function convertQueryTargetToQuery(target) {
     }
     let filterBy = [];
     if (query.where) {
-        filterBy = fromFilter(query.where);
+        filterBy = fromFilters(query.where);
     }
     let orderBy = [];
     if (query.orderBy) {
@@ -8801,7 +9050,7 @@ function convertQueryTargetToQuery(target) {
     if (query.endAt) {
         endAt = fromEndAtCursor(query.endAt);
     }
-    return newQuery(path, collectionGroup, orderBy, filterBy, limit, "F" /* First */, startAt, endAt);
+    return newQuery(path, collectionGroup, orderBy, filterBy, limit, "F" /* LimitType.First */, startAt, endAt);
 }
 function fromQueryTarget(target) {
     return queryToTarget(convertQueryTargetToQuery(target));
@@ -8819,11 +9068,11 @@ function toListenRequestLabels(serializer, targetData) {
 }
 function toLabel(serializer, purpose) {
     switch (purpose) {
-        case 0 /* Listen */:
+        case 0 /* TargetPurpose.Listen */:
             return null;
-        case 1 /* ExistenceFilterMismatch */:
+        case 1 /* TargetPurpose.ExistenceFilterMismatch */:
             return 'existence-filter-mismatch';
-        case 2 /* LimboResolution */:
+        case 2 /* TargetPurpose.LimboResolution */:
             return 'limbo-document';
         default:
             return fail();
@@ -8850,32 +9099,29 @@ function toTarget(serializer, targetData) {
     }
     return result;
 }
-function toFilter(filters) {
+function toFilters(filters) {
     if (filters.length === 0) {
         return;
     }
-    const protos = filters.map(filter => {
-        return toUnaryOrFieldFilter(filter);
-    });
-    if (protos.length === 1) {
-        return protos[0];
+    return toFilter(CompositeFilter.create(filters, "and" /* CompositeOperator.AND */));
+}
+function fromFilters(filter) {
+    const result = fromFilter(filter);
+    if (result instanceof CompositeFilter &&
+        compositeFilterIsFlatConjunction(result)) {
+        return result.getFilters();
     }
-    return { compositeFilter: { op: 'AND', filters: protos } };
+    return [result];
 }
 function fromFilter(filter) {
-    if (!filter) {
-        return [];
-    }
-    else if (filter.unaryFilter !== undefined) {
-        return [fromUnaryFilter(filter)];
+    if (filter.unaryFilter !== undefined) {
+        return fromUnaryFilter(filter);
     }
     else if (filter.fieldFilter !== undefined) {
-        return [fromFieldFilter(filter)];
+        return fromFieldFilter(filter);
     }
     else if (filter.compositeFilter !== undefined) {
-        return filter.compositeFilter
-            .filters.map(f => fromFilter(f))
-            .reduce((accum, current) => accum.concat(current));
+        return fromCompositeFilter(filter);
     }
     else {
         return fail();
@@ -8920,9 +9166,9 @@ function toDirection(dir) {
 function fromDirection(dir) {
     switch (dir) {
         case 'ASCENDING':
-            return "asc" /* ASCENDING */;
+            return "asc" /* Direction.ASCENDING */;
         case 'DESCENDING':
-            return "desc" /* DESCENDING */;
+            return "desc" /* Direction.DESCENDING */;
         default:
             return undefined;
     }
@@ -8931,34 +9177,47 @@ function fromDirection(dir) {
 function toOperatorName(op) {
     return OPERATORS[op];
 }
+function toCompositeOperatorName(op) {
+    return COMPOSITE_OPERATORS[op];
+}
 function fromOperatorName(op) {
     switch (op) {
         case 'EQUAL':
-            return "==" /* EQUAL */;
+            return "==" /* Operator.EQUAL */;
         case 'NOT_EQUAL':
-            return "!=" /* NOT_EQUAL */;
+            return "!=" /* Operator.NOT_EQUAL */;
         case 'GREATER_THAN':
-            return ">" /* GREATER_THAN */;
+            return ">" /* Operator.GREATER_THAN */;
         case 'GREATER_THAN_OR_EQUAL':
-            return ">=" /* GREATER_THAN_OR_EQUAL */;
+            return ">=" /* Operator.GREATER_THAN_OR_EQUAL */;
         case 'LESS_THAN':
-            return "<" /* LESS_THAN */;
+            return "<" /* Operator.LESS_THAN */;
         case 'LESS_THAN_OR_EQUAL':
-            return "<=" /* LESS_THAN_OR_EQUAL */;
+            return "<=" /* Operator.LESS_THAN_OR_EQUAL */;
         case 'ARRAY_CONTAINS':
-            return "array-contains" /* ARRAY_CONTAINS */;
+            return "array-contains" /* Operator.ARRAY_CONTAINS */;
         case 'IN':
-            return "in" /* IN */;
+            return "in" /* Operator.IN */;
         case 'NOT_IN':
-            return "not-in" /* NOT_IN */;
+            return "not-in" /* Operator.NOT_IN */;
         case 'ARRAY_CONTAINS_ANY':
-            return "array-contains-any" /* ARRAY_CONTAINS_ANY */;
+            return "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */;
         case 'OPERATOR_UNSPECIFIED':
             return fail();
         default:
             return fail();
     }
 }
+function fromCompositeOperatorName(op) {
+    switch (op) {
+        case 'AND':
+            return "and" /* CompositeOperator.AND */;
+        case 'OR':
+            return "or" /* CompositeOperator.OR */;
+        default:
+            return fail();
+    }
+}
 function toFieldPathReference(path) {
     return { fieldPath: path.canonicalString() };
 }
@@ -8975,12 +9234,32 @@ function toPropertyOrder(orderBy) {
 function fromPropertyOrder(orderBy) {
     return new OrderBy(fromFieldPathReference(orderBy.field), fromDirection(orderBy.direction));
 }
-function fromFieldFilter(filter) {
-    return FieldFilter.create(fromFieldPathReference(filter.fieldFilter.field), fromOperatorName(filter.fieldFilter.op), filter.fieldFilter.value);
-}
 // visible for testing
+function toFilter(filter) {
+    if (filter instanceof FieldFilter) {
+        return toUnaryOrFieldFilter(filter);
+    }
+    else if (filter instanceof CompositeFilter) {
+        return toCompositeFilter(filter);
+    }
+    else {
+        return fail();
+    }
+}
+function toCompositeFilter(filter) {
+    const protos = filter.getFilters().map(filter => toFilter(filter));
+    if (protos.length === 1) {
+        return protos[0];
+    }
+    return {
+        compositeFilter: {
+            op: toCompositeOperatorName(filter.op),
+            filters: protos
+        }
+    };
+}
 function toUnaryOrFieldFilter(filter) {
-    if (filter.op === "==" /* EQUAL */) {
+    if (filter.op === "==" /* Operator.EQUAL */) {
         if (isNanValue(filter.value)) {
             return {
                 unaryFilter: {
@@ -8998,7 +9277,7 @@ function toUnaryOrFieldFilter(filter) {
             };
         }
     }
-    else if (filter.op === "!=" /* NOT_EQUAL */) {
+    else if (filter.op === "!=" /* Operator.NOT_EQUAL */) {
         if (isNanValue(filter.value)) {
             return {
                 unaryFilter: {
@@ -9028,22 +9307,22 @@ function fromUnaryFilter(filter) {
     switch (filter.unaryFilter.op) {
         case 'IS_NAN':
             const nanField = fromFieldPathReference(filter.unaryFilter.field);
-            return FieldFilter.create(nanField, "==" /* EQUAL */, {
+            return FieldFilter.create(nanField, "==" /* Operator.EQUAL */, {
                 doubleValue: NaN
             });
         case 'IS_NULL':
             const nullField = fromFieldPathReference(filter.unaryFilter.field);
-            return FieldFilter.create(nullField, "==" /* EQUAL */, {
+            return FieldFilter.create(nullField, "==" /* Operator.EQUAL */, {
                 nullValue: 'NULL_VALUE'
             });
         case 'IS_NOT_NAN':
             const notNanField = fromFieldPathReference(filter.unaryFilter.field);
-            return FieldFilter.create(notNanField, "!=" /* NOT_EQUAL */, {
+            return FieldFilter.create(notNanField, "!=" /* Operator.NOT_EQUAL */, {
                 doubleValue: NaN
             });
         case 'IS_NOT_NULL':
             const notNullField = fromFieldPathReference(filter.unaryFilter.field);
-            return FieldFilter.create(notNullField, "!=" /* NOT_EQUAL */, {
+            return FieldFilter.create(notNullField, "!=" /* Operator.NOT_EQUAL */, {
                 nullValue: 'NULL_VALUE'
             });
         case 'OPERATOR_UNSPECIFIED':
@@ -9052,6 +9331,12 @@ function fromUnaryFilter(filter) {
             return fail();
     }
 }
+function fromFieldFilter(filter) {
+    return FieldFilter.create(fromFieldPathReference(filter.fieldFilter.field), fromOperatorName(filter.fieldFilter.op), filter.fieldFilter.value);
+}
+function fromCompositeFilter(filter) {
+    return CompositeFilter.create(filter.compositeFilter.filters.map(filter => fromFilter(filter)), fromCompositeOperatorName(filter.compositeFilter.op));
+}
 function toDocumentMask(fieldMask) {
     const canonicalFields = [];
     fieldMask.fields.forEach(field => canonicalFields.push(field.canonicalString()));
@@ -9291,7 +9576,7 @@ function fromDbTarget(dbTarget) {
     else {
         target = fromQueryTarget(dbTarget.query);
     }
-    return new TargetData(target, dbTarget.targetId, 0 /* Listen */, dbTarget.lastListenSequenceNumber, version, lastLimboFreeSnapshotVersion, ByteString.fromBase64String(dbTarget.resumeToken));
+    return new TargetData(target, dbTarget.targetId, 0 /* TargetPurpose.Listen */, dbTarget.lastListenSequenceNumber, version, lastLimboFreeSnapshotVersion, ByteString.fromBase64String(dbTarget.resumeToken));
 }
 /** Encodes TargetData into a DbTarget for storage locally. */
 function toDbTarget(localSerializer, targetData) {
@@ -9368,7 +9653,7 @@ function fromBundledQuery(bundledQuery) {
         structuredQuery: bundledQuery.structuredQuery
     });
     if (bundledQuery.limitType === 'LAST') {
-        return queryWithLimit(query, query.limit, "L" /* Last */);
+        return queryWithLimit(query, query.limit, "L" /* LimitType.Last */);
     }
     return query;
 }
@@ -10143,7 +10428,7 @@ class IndexByteEncoder {
         this.orderedCode.seed(encodedBytes);
     }
     forKind(kind) {
-        return kind === 0 /* ASCENDING */ ? this.ascending : this.descending;
+        return kind === 0 /* IndexKind.ASCENDING */ ? this.ascending : this.descending;
     }
     encodedBytes() {
         return this.orderedCode.encodedBytes();
@@ -10298,6 +10583,7 @@ class TargetIndexMatcher {
      *   omitted.
      */
     servedByIndex(index) {
+        hardAssert(index.collectionGroup === this.collectionId);
         // If there is an array element, find a matching filter.
         const arraySegment = fieldIndexGetArraySegment(index);
         if (arraySegment !== undefined &&
@@ -10361,19 +10647,268 @@ class TargetIndexMatcher {
         if (filter === undefined || !filter.field.isEqual(segment.fieldPath)) {
             return false;
         }
-        const isArrayOperator = filter.op === "array-contains" /* ARRAY_CONTAINS */ ||
-            filter.op === "array-contains-any" /* ARRAY_CONTAINS_ANY */;
-        return (segment.kind === 2 /* CONTAINS */) === isArrayOperator;
+        const isArrayOperator = filter.op === "array-contains" /* Operator.ARRAY_CONTAINS */ ||
+            filter.op === "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */;
+        return (segment.kind === 2 /* IndexKind.CONTAINS */) === isArrayOperator;
     }
     matchesOrderBy(orderBy, segment) {
         if (!orderBy.field.isEqual(segment.fieldPath)) {
             return false;
         }
-        return ((segment.kind === 0 /* ASCENDING */ &&
-            orderBy.dir === "asc" /* ASCENDING */) ||
-            (segment.kind === 1 /* DESCENDING */ &&
-                orderBy.dir === "desc" /* DESCENDING */));
+        return ((segment.kind === 0 /* IndexKind.ASCENDING */ &&
+            orderBy.dir === "asc" /* Direction.ASCENDING */) ||
+            (segment.kind === 1 /* IndexKind.DESCENDING */ &&
+                orderBy.dir === "desc" /* Direction.DESCENDING */));
+    }
+}
+
+/**
+ * @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.
+ */
+/**
+ * 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.
+ */
+function computeInExpansion(filter) {
+    var _a, _b;
+    hardAssert(filter instanceof FieldFilter || filter instanceof CompositeFilter);
+    if (filter instanceof FieldFilter) {
+        if (filter instanceof InFilter) {
+            const expandedFilters = ((_b = (_a = filter.value.arrayValue) === null || _a === void 0 ? void 0 : _a.values) === null || _b === void 0 ? void 0 : _b.map(value => FieldFilter.create(filter.field, "==" /* Operator.EQUAL */, value))) || [];
+            return CompositeFilter.create(expandedFilters, "or" /* CompositeOperator.OR */);
+        }
+        else {
+            // We have reached other kinds of field filters.
+            return filter;
+        }
+    }
+    // We have a composite filter.
+    const expandedFilters = filter.filters.map(subfilter => computeInExpansion(subfilter));
+    return CompositeFilter.create(expandedFilters, filter.op);
+}
+/**
+ * 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.
+ */
+function getDnfTerms(filter) {
+    if (filter.getFilters().length === 0) {
+        return [];
+    }
+    const result = computeDistributedNormalForm(computeInExpansion(filter));
+    hardAssert(isDisjunctiveNormalForm(result));
+    if (isSingleFieldFilter(result) || isFlatConjunction(result)) {
+        return [result];
+    }
+    return result.getFilters();
+}
+/** Returns true if the given filter is a single field filter. e.g. (a == 10). */
+function isSingleFieldFilter(filter) {
+    return filter instanceof FieldFilter;
+}
+/**
+ * Returns true if the given filter is the conjunction of one or more field filters. e.g. (a == 10
+ * && b == 20)
+ */
+function isFlatConjunction(filter) {
+    return (filter instanceof CompositeFilter &&
+        compositeFilterIsFlatConjunction(filter));
+}
+/**
+ * Returns whether or not the given filter is in disjunctive normal form (DNF).
+ *
+ * <p>In boolean logic, a disjunctive normal form (DNF) is a canonical normal form of a logical
+ * formula consisting of a disjunction of conjunctions; it can also be described as an OR of ANDs.
+ *
+ * <p>For more info, visit: https://en.wikipedia.org/wiki/Disjunctive_normal_form
+ */
+function isDisjunctiveNormalForm(filter) {
+    return (isSingleFieldFilter(filter) ||
+        isFlatConjunction(filter) ||
+        isDisjunctionOfFieldFiltersAndFlatConjunctions(filter));
+}
+/**
+ * Returns true if the given filter is the disjunction of one or more "flat conjunctions" and
+ * field filters. e.g. (a == 10) || (b==20 && c==30)
+ */
+function isDisjunctionOfFieldFiltersAndFlatConjunctions(filter) {
+    if (filter instanceof CompositeFilter) {
+        if (compositeFilterIsDisjunction(filter)) {
+            for (const subFilter of filter.getFilters()) {
+                if (!isSingleFieldFilter(subFilter) && !isFlatConjunction(subFilter)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+    return false;
+}
+function computeDistributedNormalForm(filter) {
+    hardAssert(filter instanceof FieldFilter || filter instanceof CompositeFilter);
+    if (filter instanceof FieldFilter) {
+        return filter;
+    }
+    if (filter.filters.length === 1) {
+        return computeDistributedNormalForm(filter.filters[0]);
+    }
+    // Compute DNF for each of the subfilters first
+    const result = filter.filters.map(subfilter => computeDistributedNormalForm(subfilter));
+    let newFilter = CompositeFilter.create(result, filter.op);
+    newFilter = applyAssociation(newFilter);
+    if (isDisjunctiveNormalForm(newFilter)) {
+        return newFilter;
+    }
+    hardAssert(newFilter instanceof CompositeFilter);
+    hardAssert(compositeFilterIsConjunction(newFilter));
+    hardAssert(newFilter.filters.length > 1);
+    return newFilter.filters.reduce((runningResult, filter) => applyDistribution(runningResult, filter));
+}
+function applyDistribution(lhs, rhs) {
+    hardAssert(lhs instanceof FieldFilter || lhs instanceof CompositeFilter);
+    hardAssert(rhs instanceof FieldFilter || rhs instanceof CompositeFilter);
+    let result;
+    if (lhs instanceof FieldFilter) {
+        if (rhs instanceof FieldFilter) {
+            // FieldFilter FieldFilter
+            result = applyDistributionFieldFilters(lhs, rhs);
+        }
+        else {
+            // FieldFilter CompositeFilter
+            result = applyDistributionFieldAndCompositeFilters(lhs, rhs);
+        }
+    }
+    else {
+        if (rhs instanceof FieldFilter) {
+            // CompositeFilter FieldFilter
+            result = applyDistributionFieldAndCompositeFilters(rhs, lhs);
+        }
+        else {
+            // CompositeFilter CompositeFilter
+            result = applyDistributionCompositeFilters(lhs, rhs);
+        }
+    }
+    return applyAssociation(result);
+}
+function applyDistributionFieldFilters(lhs, rhs) {
+    // Conjunction distribution for two field filters is the conjunction of them.
+    return CompositeFilter.create([lhs, rhs], "and" /* CompositeOperator.AND */);
+}
+function applyDistributionCompositeFilters(lhs, rhs) {
+    hardAssert(lhs.filters.length > 0 && rhs.filters.length > 0);
+    // There are four cases:
+    // (A & B) & (C & D) --> (A & B & C & D)
+    // (A & B) & (C | D) --> (A & B & C) | (A & B & D)
+    // (A | B) & (C & D) --> (C & D & A) | (C & D & B)
+    // (A | B) & (C | D) --> (A & C) | (A & D) | (B & C) | (B & D)
+    // Case 1 is a merge.
+    if (compositeFilterIsConjunction(lhs) && compositeFilterIsConjunction(rhs)) {
+        return compositeFilterWithAddedFilters(lhs, rhs.getFilters());
+    }
+    // Case 2,3,4 all have at least one side (lhs or rhs) that is a disjunction. In all three cases
+    // we should take each element of the disjunction and distribute it over the other side, and
+    // return the disjunction of the distribution results.
+    const disjunctionSide = compositeFilterIsDisjunction(lhs) ? lhs : rhs;
+    const otherSide = compositeFilterIsDisjunction(lhs) ? rhs : lhs;
+    const results = disjunctionSide.filters.map(subfilter => applyDistribution(subfilter, otherSide));
+    return CompositeFilter.create(results, "or" /* CompositeOperator.OR */);
+}
+function applyDistributionFieldAndCompositeFilters(fieldFilter, compositeFilter) {
+    // There are two cases:
+    // A & (B & C) --> (A & B & C)
+    // A & (B | C) --> (A & B) | (A & C)
+    if (compositeFilterIsConjunction(compositeFilter)) {
+        // Case 1
+        return compositeFilterWithAddedFilters(compositeFilter, fieldFilter.getFilters());
+    }
+    else {
+        // Case 2
+        const newFilters = compositeFilter.filters.map(subfilter => applyDistribution(fieldFilter, subfilter));
+        return CompositeFilter.create(newFilters, "or" /* CompositeOperator.OR */);
+    }
+}
+/**
+ * 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
+ */
+function applyAssociation(filter) {
+    hardAssert(filter instanceof FieldFilter || filter instanceof CompositeFilter);
+    if (filter instanceof FieldFilter) {
+        return filter;
+    }
+    const filters = filter.getFilters();
+    // If the composite filter only contains 1 filter, apply associativity to it.
+    if (filters.length === 1) {
+        return applyAssociation(filters[0]);
+    }
+    // Associativity applied to a flat composite filter results is itself.
+    if (compositeFilterIsFlat(filter)) {
+        return filter;
+    }
+    // First apply associativity to all subfilters. This will in turn recursively apply
+    // associativity to all nested composite filters and field filters.
+    const updatedFilters = filters.map(subfilter => applyAssociation(subfilter));
+    // For composite subfilters that perform the same kind of logical operation as `compositeFilter`
+    // take out their filters and add them to `compositeFilter`. For example:
+    // compositeFilter = (A | (B | C | D))
+    // compositeSubfilter = (B | C | D)
+    // Result: (A | B | C | D)
+    // Note that the `compositeSubfilter` has been eliminated, and its filters (B, C, D) have been
+    // added to the top-level "compositeFilter".
+    const newSubfilters = [];
+    updatedFilters.forEach(subfilter => {
+        if (subfilter instanceof FieldFilter) {
+            newSubfilters.push(subfilter);
+        }
+        else if (subfilter instanceof CompositeFilter) {
+            if (subfilter.op === filter.op) {
+                // compositeFilter: (A | (B | C))
+                // compositeSubfilter: (B | C)
+                // Result: (A | B | C)
+                newSubfilters.push(...subfilter.filters);
+            }
+            else {
+                // compositeFilter: (A | (B & C))
+                // compositeSubfilter: (B & C)
+                // Result: (A | (B & C))
+                newSubfilters.push(subfilter);
+            }
+        }
+    });
+    if (newSubfilters.length === 1) {
+        return newSubfilters[0];
     }
+    return CompositeFilter.create(newSubfilters, filter.op);
 }
 
 /**
@@ -10420,7 +10955,7 @@ class MemoryIndexManager {
     }
     getIndexType(transaction, target) {
         // Field indices are not supported with memory persistence.
-        return PersistencePromise.resolve(0 /* NONE */);
+        return PersistencePromise.resolve(0 /* IndexType.NONE */);
     }
     getFieldIndexes(transaction, collectionGroup) {
         // Field indices are not supported with memory persistence.
@@ -10643,8 +11178,14 @@ class IndexedDbIndexManager {
         if (subTargets) {
             return subTargets;
         }
-        // TODO(orquery): Implement DNF transform
-        subTargets = [target];
+        if (target.filters.length === 0) {
+            subTargets = [target];
+        }
+        else {
+            // There is an implicit AND operation between all the filters stored in the target
+            const dnf = getDnfTerms(CompositeFilter.create(target.filters, "and" /* CompositeOperator.AND */));
+            subTargets = dnf.map(term => newTarget(target.path, target.collectionGroup, target.orderBy, term.getFilters(), target.limit, target.startAt, target.endAt));
+        }
         this.targetToDnfSubTargets.set(target, subTargets);
         return subTargets;
     }
@@ -10702,18 +11243,29 @@ class IndexedDbIndexManager {
         });
     }
     getIndexType(transaction, target) {
-        let indexType = 2 /* FULL */;
-        return PersistencePromise.forEach(this.getSubTargets(target), (target) => {
+        let indexType = 2 /* IndexType.FULL */;
+        const subTargets = this.getSubTargets(target);
+        return PersistencePromise.forEach(subTargets, (target) => {
             return this.getFieldIndex(transaction, target).next(index => {
                 if (!index) {
-                    indexType = 0 /* NONE */;
+                    indexType = 0 /* IndexType.NONE */;
                 }
-                else if (indexType !== 0 /* NONE */ &&
+                else if (indexType !== 0 /* IndexType.NONE */ &&
                     index.fields.length < targetGetSegmentCount(target)) {
-                    indexType = 1 /* PARTIAL */;
+                    indexType = 1 /* IndexType.PARTIAL */;
                 }
             });
-        }).next(() => indexType);
+        }).next(() => {
+            // OR queries have more than one sub-target (one sub-target per DNF term). We currently consider
+            // OR queries that have a `limit` to have a partial index. For such queries we perform sorting
+            // and apply the limit in memory as a post-processing step.
+            if (targetHasLimit(target) &&
+                subTargets.length > 1 &&
+                indexType === 2 /* IndexType.FULL */) {
+                return 1 /* IndexType.PARTIAL */;
+            }
+            return indexType;
+        });
     }
     /**
      * Returns the byte encoded form of the directional values in the field index.
@@ -10735,7 +11287,7 @@ class IndexedDbIndexManager {
     /** Encodes a single value to the ascending index format. */
     encodeSingleElement(value) {
         const encoder = new IndexByteEncoder();
-        FirestoreIndexValueWriter.INSTANCE.writeIndexValue(value, encoder.forKind(0 /* ASCENDING */));
+        FirestoreIndexValueWriter.INSTANCE.writeIndexValue(value, encoder.forKind(0 /* IndexKind.ASCENDING */));
         return encoder.encodedBytes();
     }
     /**
@@ -10751,15 +11303,15 @@ class IndexedDbIndexManager {
      * Encodes the given field values according to the specification in `target`.
      * For IN queries, a list of possible values is returned.
      */
-    encodeValues(fieldIndex, target, bound) {
-        if (bound === null) {
+    encodeValues(fieldIndex, target, values) {
+        if (values === null) {
             return [];
         }
         let encoders = [];
         encoders.push(new IndexByteEncoder());
-        let boundIdx = 0;
+        let valueIdx = 0;
         for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
-            const value = bound[boundIdx++];
+            const value = values[valueIdx++];
             for (const encoder of encoders) {
                 if (this.isInFilter(target, segment.fieldPath) && isArray(value)) {
                     encoders = this.expandIndexValues(encoders, segment, value);
@@ -10810,7 +11362,7 @@ class IndexedDbIndexManager {
     isInFilter(target, fieldPath) {
         return !!target.filters.find(f => f instanceof FieldFilter &&
             f.field.isEqual(fieldPath) &&
-            (f.op === "in" /* IN */ || f.op === "not-in" /* NOT_IN */));
+            (f.op === "in" /* Operator.IN */ || f.op === "not-in" /* Operator.NOT_IN */));
     }
     getFieldIndexes(transaction, collectionGroup) {
         const indexes = indexConfigurationStore(transaction);
@@ -10999,24 +11551,36 @@ class IndexedDbIndexManager {
         bounds.push(upper);
         const ranges = [];
         for (let i = 0; i < bounds.length; i += 2) {
-            ranges.push(IDBKeyRange.bound([
+            // If we encounter two bounds that will create an unmatchable key range,
+            // then we return an empty set of key ranges.
+            if (this.isRangeMatchable(bounds[i], bounds[i + 1])) {
+                return [];
+            }
+            const lowerBound = [
                 bounds[i].indexId,
                 this.uid,
                 bounds[i].arrayValue,
                 bounds[i].directionalValue,
                 EMPTY_VALUE,
                 []
-            ], [
+            ];
+            const upperBound = [
                 bounds[i + 1].indexId,
                 this.uid,
                 bounds[i + 1].arrayValue,
                 bounds[i + 1].directionalValue,
                 EMPTY_VALUE,
                 []
-            ]));
+            ];
+            ranges.push(IDBKeyRange.bound(lowerBound, upperBound));
         }
         return ranges;
     }
+    isRangeMatchable(lowerBound, upperBound) {
+        // If lower bound is greater than the upper bound, then the key
+        // range can never be matched.
+        return indexEntryComparator(lowerBound, upperBound) > 0;
+    }
     getMinOffsetFromCollectionGroup(transaction, collectionGroup) {
         return this.getFieldIndexes(transaction, collectionGroup).next(getMinOffsetFromFieldIndexes);
     }
@@ -11993,7 +12557,7 @@ class LruScheduler {
     }
     scheduleGC(delay) {
         logDebug(LOG_TAG$e, `Garbage collection scheduled in ${delay}ms`);
-        this.gcTask = this.asyncQueue.enqueueAfterDelay("lru_garbage_collection" /* LruGarbageCollection */, delay, async () => {
+        this.gcTask = this.asyncQueue.enqueueAfterDelay("lru_garbage_collection" /* TimerId.LruGarbageCollection */, delay, async () => {
             this.gcTask = null;
             try {
                 await this.localStore.collectGarbage(this.garbageCollector);
@@ -12891,7 +13455,7 @@ class LocalDocumentsView {
             .getOverlay(transaction, key)
             .next(value => {
             overlay = value;
-            return this.getBaseDocument(transaction, key, overlay);
+            return this.remoteDocumentCache.getEntry(transaction, key);
         })
             .next(document => {
             if (overlay !== null) {
@@ -13114,7 +13678,9 @@ class LocalDocumentsView {
                     if (originalDocs.get(key)) {
                         return PersistencePromise.resolve();
                     }
-                    return this.getBaseDocument(transaction, key, overlay).next(doc => {
+                    return this.remoteDocumentCache
+                        .getEntry(transaction, key)
+                        .next(doc => {
                         modifiedDocs = modifiedDocs.insert(key, doc);
                     });
                 })
@@ -13188,12 +13754,6 @@ class LocalDocumentsView {
             return results;
         });
     }
-    /** Returns a base document that can be used to apply `overlay`. */
-    getBaseDocument(transaction, key, overlay) {
-        return overlay === null || overlay.mutation.type === 1 /* Patch */
-            ? this.remoteDocumentCache.getEntry(transaction, key)
-            : PersistencePromise.resolve(MutableDocument.newInvalidDocument(key));
-    }
 }
 
 /**
@@ -14943,7 +15503,7 @@ class IndexedDbPersistence {
      * extend or acquire the primary lease if the client is eligible.
      */
     scheduleClientMetadataAndPrimaryLeaseRefreshes() {
-        this.clientMetadataRefresher = this.queue.enqueueAfterDelay("client_metadata_refresh" /* ClientMetadataRefresh */, CLIENT_METADATA_REFRESH_INTERVAL_MS, () => {
+        this.clientMetadataRefresher = this.queue.enqueueAfterDelay("client_metadata_refresh" /* TimerId.ClientMetadataRefresh */, CLIENT_METADATA_REFRESH_INTERVAL_MS, () => {
             return this.updateClientMetadataAndTryBecomePrimary()
                 .then(() => this.maybeGarbageCollectMultiClientState())
                 .then(() => this.scheduleClientMetadataAndPrimaryLeaseRefreshes());
@@ -15953,7 +16513,7 @@ function localStoreAllocateTarget(localStore, target) {
                 return localStoreImpl.targetCache
                     .allocateTargetId(txn)
                     .next(targetId => {
-                    targetData = new TargetData(target, targetId, 0 /* Listen */, txn.currentSequenceNumber);
+                    targetData = new TargetData(target, targetId, 0 /* TargetPurpose.Listen */, txn.currentSequenceNumber);
                     return localStoreImpl.targetCache
                         .addTargetData(txn, targetData)
                         .next(() => targetData);
@@ -16375,11 +16935,11 @@ class QueryEngine {
         return this.indexManager
             .getIndexType(transaction, target)
             .next(indexType => {
-            if (indexType === 0 /* NONE */) {
+            if (indexType === 0 /* IndexType.NONE */) {
                 // The target cannot be served from any index.
                 return null;
             }
-            if (query.limit !== null && indexType === 1 /* PARTIAL */) {
+            if (query.limit !== null && indexType === 1 /* IndexType.PARTIAL */) {
                 // We cannot apply a limit for targets that are served using a partial
                 // index. If a partial index will be used to serve the target, the
                 // query may return a superset of documents that match the target
@@ -16387,7 +16947,7 @@ class QueryEngine {
                 // may return the correct set of documents in the wrong order (e.g. if
                 // the index doesn't include a segment for one of the orderBys).
                 // Therefore, a limit should not be applied in such cases.
-                query = queryWithLimit(query, null, "F" /* First */);
+                query = queryWithLimit(query, null, "F" /* LimitType.First */);
                 target = queryToTarget(query);
             }
             return this.indexManager
@@ -16408,7 +16968,7 @@ class QueryEngine {
                             // query's filters are included in the result set. The SDK
                             // can then apply the limit once all local edits are
                             // incorporated.
-                            return this.performQueryUsingIndex(transaction, queryWithLimit(query, null, "F" /* First */));
+                            return this.performQueryUsingIndex(transaction, queryWithLimit(query, null, "F" /* LimitType.First */));
                         }
                         return this.appendRemainingResults(transaction, previousResults, query, offset);
                     });
@@ -16487,7 +17047,7 @@ class QueryEngine {
         // the boundary of the limit itself did not change and documents from cache
         // will continue to be "rejected" by this boundary. Therefore, we can ignore
         // any modifications that don't affect the last document.
-        const docAtLimitEdge = query.limitType === "F" /* First */
+        const docAtLimitEdge = query.limitType === "F" /* LimitType.First */
             ? sortedPreviousResults.last()
             : sortedPreviousResults.first();
         if (!docAtLimitEdge) {
@@ -17408,7 +17968,7 @@ function nodePromise(action) {
  */
 // TODO: Fetch runtime version from grpc-js/package.json instead
 // when there's a cleaner way to dynamic require JSON in both Node ESM and CJS
-const grpcVersion = '1.3.7';
+const grpcVersion = '1.7.3';
 const LOG_TAG$9 = 'Connection';
 const X_GOOG_API_CLIENT_VALUE = `gl-node/${process.versions.node} fire/${SDK_VERSION} grpc/${grpcVersion}`;
 function createMetadata(databasePath, authToken, appCheckToken, appId) {
@@ -19856,7 +20416,8 @@ const nested = {
 											Operator: {
 												values: {
 													OPERATOR_UNSPECIFIED: 0,
-													AND: 1
+													AND: 1,
+													OR: 2
 												}
 											}
 										}
@@ -20732,7 +21293,7 @@ class PersistentStream {
         this.authCredentialsProvider = authCredentialsProvider;
         this.appCheckCredentialsProvider = appCheckCredentialsProvider;
         this.listener = listener;
-        this.state = 0 /* Initial */;
+        this.state = 0 /* PersistentStreamState.Initial */;
         /**
          * A close count that's incremented every time the stream is closed; used by
          * getCloseGuardedDispatcher() to invalidate callbacks that happen after
@@ -20752,8 +21313,8 @@ class PersistentStream {
      * outbound requests.
      */
     isStarted() {
-        return (this.state === 1 /* Starting */ ||
-            this.state === 5 /* Backoff */ ||
+        return (this.state === 1 /* PersistentStreamState.Starting */ ||
+            this.state === 5 /* PersistentStreamState.Backoff */ ||
             this.isOpen());
     }
     /**
@@ -20761,8 +21322,8 @@ class PersistentStream {
      * called) and the stream is ready for outbound requests.
      */
     isOpen() {
-        return (this.state === 2 /* Open */ ||
-            this.state === 3 /* Healthy */);
+        return (this.state === 2 /* PersistentStreamState.Open */ ||
+            this.state === 3 /* PersistentStreamState.Healthy */);
     }
     /**
      * Starts the RPC. Only allowed if isStarted() returns false. The stream is
@@ -20772,7 +21333,7 @@ class PersistentStream {
      * When start returns, isStarted() will return true.
      */
     start() {
-        if (this.state === 4 /* Error */) {
+        if (this.state === 4 /* PersistentStreamState.Error */) {
             this.performBackoff();
             return;
         }
@@ -20786,7 +21347,7 @@ class PersistentStream {
      */
     async stop() {
         if (this.isStarted()) {
-            await this.close(0 /* Initial */);
+            await this.close(0 /* PersistentStreamState.Initial */);
         }
     }
     /**
@@ -20798,7 +21359,7 @@ class PersistentStream {
      * inhibit backoff if required.
      */
     inhibitBackoff() {
-        this.state = 0 /* Initial */;
+        this.state = 0 /* PersistentStreamState.Initial */;
         this.backoff.reset();
     }
     /**
@@ -20828,7 +21389,7 @@ class PersistentStream {
         if (this.isOpen()) {
             // When timing out an idle stream there's no reason to force the stream into backoff when
             // it restarts so set the stream state to Initial instead of Error.
-            return this.close(0 /* Initial */);
+            return this.close(0 /* PersistentStreamState.Initial */);
         }
     }
     /** Marks the stream as active again. */
@@ -20866,7 +21427,7 @@ class PersistentStream {
         // Invalidates any stream-related callbacks (e.g. from auth or the
         // underlying stream), guaranteeing they won't execute.
         this.closeCount++;
-        if (finalState !== 4 /* Error */) {
+        if (finalState !== 4 /* PersistentStreamState.Error */) {
             // If this is an intentional close ensure we don't delay our next connection attempt.
             this.backoff.reset();
         }
@@ -20878,7 +21439,7 @@ class PersistentStream {
         }
         else if (error &&
             error.code === Code.UNAUTHENTICATED &&
-            this.state !== 3 /* Healthy */) {
+            this.state !== 3 /* PersistentStreamState.Healthy */) {
             // "unauthenticated" error means the token was rejected. This should rarely
             // happen since both Auth and AppCheck ensure a sufficient TTL when we
             // request a token. If a user manually resets their system clock this can
@@ -20906,7 +21467,7 @@ class PersistentStream {
      */
     tearDown() { }
     auth() {
-        this.state = 1 /* Starting */;
+        this.state = 1 /* PersistentStreamState.Starting */;
         const dispatchIfNotClosed = this.getCloseGuardedDispatcher(this.closeCount);
         // TODO(mikelehen): Just use dispatchIfNotClosed, but see TODO below.
         const closeCount = this.closeCount;
@@ -20936,10 +21497,10 @@ class PersistentStream {
         this.stream = this.startRpc(authToken, appCheckToken);
         this.stream.onOpen(() => {
             dispatchIfNotClosed(() => {
-                this.state = 2 /* Open */;
+                this.state = 2 /* PersistentStreamState.Open */;
                 this.healthCheck = this.queue.enqueueAfterDelay(this.healthTimerId, HEALTHY_TIMEOUT_MS, () => {
                     if (this.isOpen()) {
-                        this.state = 3 /* Healthy */;
+                        this.state = 3 /* PersistentStreamState.Healthy */;
                     }
                     return Promise.resolve();
                 });
@@ -20958,9 +21519,9 @@ class PersistentStream {
         });
     }
     performBackoff() {
-        this.state = 5 /* Backoff */;
+        this.state = 5 /* PersistentStreamState.Backoff */;
         this.backoff.backoffAndRun(async () => {
-            this.state = 0 /* Initial */;
+            this.state = 0 /* PersistentStreamState.Initial */;
             this.start();
         });
     }
@@ -20972,7 +21533,7 @@ class PersistentStream {
         // we never expect this to happen because if we stop a stream ourselves,
         // this callback will never be called. To prevent cases where we retry
         // without a backoff accidentally, we set the stream to error in all cases.
-        return this.close(4 /* Error */, error);
+        return this.close(4 /* PersistentStreamState.Error */, error);
     }
     /**
      * Returns a "dispatcher" function that dispatches operations onto the
@@ -21003,7 +21564,7 @@ class PersistentStream {
  */
 class PersistentListenStream extends PersistentStream {
     constructor(queue, connection, authCredentials, appCheckCredentials, serializer, listener) {
-        super(queue, "listen_stream_connection_backoff" /* ListenStreamConnectionBackoff */, "listen_stream_idle" /* ListenStreamIdle */, "health_check_timeout" /* HealthCheckTimeout */, connection, authCredentials, appCheckCredentials, listener);
+        super(queue, "listen_stream_connection_backoff" /* TimerId.ListenStreamConnectionBackoff */, "listen_stream_idle" /* TimerId.ListenStreamIdle */, "health_check_timeout" /* TimerId.HealthCheckTimeout */, connection, authCredentials, appCheckCredentials, listener);
         this.serializer = serializer;
     }
     startRpc(authToken, appCheckToken) {
@@ -21062,7 +21623,7 @@ class PersistentListenStream extends PersistentStream {
  */
 class PersistentWriteStream extends PersistentStream {
     constructor(queue, connection, authCredentials, appCheckCredentials, serializer, listener) {
-        super(queue, "write_stream_connection_backoff" /* WriteStreamConnectionBackoff */, "write_stream_idle" /* WriteStreamIdle */, "health_check_timeout" /* HealthCheckTimeout */, connection, authCredentials, appCheckCredentials, listener);
+        super(queue, "write_stream_connection_backoff" /* TimerId.WriteStreamConnectionBackoff */, "write_stream_idle" /* TimerId.WriteStreamIdle */, "health_check_timeout" /* TimerId.HealthCheckTimeout */, connection, authCredentials, appCheckCredentials, listener);
         this.serializer = serializer;
         this.handshakeComplete_ = false;
     }
@@ -21321,7 +21882,7 @@ class OnlineStateTracker {
         this.asyncQueue = asyncQueue;
         this.onlineStateHandler = onlineStateHandler;
         /** The current OnlineState. */
-        this.state = "Unknown" /* Unknown */;
+        this.state = "Unknown" /* OnlineState.Unknown */;
         /**
          * A count of consecutive failures to open the stream. If it reaches the
          * maximum defined by MAX_WATCH_STREAM_FAILURES, we'll set the OnlineState to
@@ -21350,12 +21911,12 @@ class OnlineStateTracker {
      */
     handleWatchStreamStart() {
         if (this.watchStreamFailures === 0) {
-            this.setAndBroadcast("Unknown" /* Unknown */);
-            this.onlineStateTimer = this.asyncQueue.enqueueAfterDelay("online_state_timeout" /* OnlineStateTimeout */, ONLINE_STATE_TIMEOUT_MS, () => {
+            this.setAndBroadcast("Unknown" /* OnlineState.Unknown */);
+            this.onlineStateTimer = this.asyncQueue.enqueueAfterDelay("online_state_timeout" /* TimerId.OnlineStateTimeout */, ONLINE_STATE_TIMEOUT_MS, () => {
                 this.onlineStateTimer = null;
                 this.logClientOfflineWarningIfNecessary(`Backend didn't respond within ${ONLINE_STATE_TIMEOUT_MS / 1000} ` +
                     `seconds.`);
-                this.setAndBroadcast("Offline" /* Offline */);
+                this.setAndBroadcast("Offline" /* OnlineState.Offline */);
                 // NOTE: handleWatchStreamFailure() will continue to increment
                 // watchStreamFailures even though we are already marked Offline,
                 // but this is non-harmful.
@@ -21370,8 +21931,8 @@ class OnlineStateTracker {
      * actually transition to the 'Offline' state.
      */
     handleWatchStreamFailure(error) {
-        if (this.state === "Online" /* Online */) {
-            this.setAndBroadcast("Unknown" /* Unknown */);
+        if (this.state === "Online" /* OnlineState.Online */) {
+            this.setAndBroadcast("Unknown" /* OnlineState.Unknown */);
         }
         else {
             this.watchStreamFailures++;
@@ -21379,7 +21940,7 @@ class OnlineStateTracker {
                 this.clearOnlineStateTimer();
                 this.logClientOfflineWarningIfNecessary(`Connection failed ${MAX_WATCH_STREAM_FAILURES} ` +
                     `times. Most recent error: ${error.toString()}`);
-                this.setAndBroadcast("Offline" /* Offline */);
+                this.setAndBroadcast("Offline" /* OnlineState.Offline */);
             }
         }
     }
@@ -21393,7 +21954,7 @@ class OnlineStateTracker {
     set(newState) {
         this.clearOnlineStateTimer();
         this.watchStreamFailures = 0;
-        if (newState === "Online" /* Online */) {
+        if (newState === "Online" /* OnlineState.Online */) {
             // We've connected to watch at least once. Don't warn the developer
             // about being offline going forward.
             this.shouldWarnClientIsOffline = false;
@@ -21520,7 +22081,7 @@ function newRemoteStore(localStore, datastore, asyncQueue, onlineStateHandler, c
 /** Re-enables the network. Idempotent. */
 function remoteStoreEnableNetwork(remoteStore) {
     const remoteStoreImpl = debugCast(remoteStore);
-    remoteStoreImpl.offlineCauses.delete(0 /* UserDisabled */);
+    remoteStoreImpl.offlineCauses.delete(0 /* OfflineCause.UserDisabled */);
     return enableNetworkInternal(remoteStoreImpl);
 }
 async function enableNetworkInternal(remoteStoreImpl) {
@@ -21536,10 +22097,10 @@ async function enableNetworkInternal(remoteStoreImpl) {
  */
 async function remoteStoreDisableNetwork(remoteStore) {
     const remoteStoreImpl = debugCast(remoteStore);
-    remoteStoreImpl.offlineCauses.add(0 /* UserDisabled */);
+    remoteStoreImpl.offlineCauses.add(0 /* OfflineCause.UserDisabled */);
     await disableNetworkInternal(remoteStoreImpl);
     // Set the OnlineState to Offline so get()s return from cache, etc.
-    remoteStoreImpl.onlineStateTracker.set("Offline" /* Offline */);
+    remoteStoreImpl.onlineStateTracker.set("Offline" /* OnlineState.Offline */);
 }
 async function disableNetworkInternal(remoteStoreImpl) {
     for (const networkStatusHandler of remoteStoreImpl.onNetworkStatusChange) {
@@ -21549,12 +22110,12 @@ async function disableNetworkInternal(remoteStoreImpl) {
 async function remoteStoreShutdown(remoteStore) {
     const remoteStoreImpl = debugCast(remoteStore);
     logDebug(LOG_TAG$5, 'RemoteStore shutting down.');
-    remoteStoreImpl.offlineCauses.add(5 /* Shutdown */);
+    remoteStoreImpl.offlineCauses.add(5 /* OfflineCause.Shutdown */);
     await disableNetworkInternal(remoteStoreImpl);
     remoteStoreImpl.connectivityMonitor.shutdown();
     // Set the OnlineState to Unknown (rather than Offline) to avoid potentially
     // triggering spurious listener events with cached data, etc.
-    remoteStoreImpl.onlineStateTracker.set("Unknown" /* Unknown */);
+    remoteStoreImpl.onlineStateTracker.set("Unknown" /* OnlineState.Unknown */);
 }
 /**
  * Starts new listen for the given target. Uses resume token if provided. It
@@ -21594,7 +22155,7 @@ function remoteStoreUnlisten(remoteStore, targetId) {
             // Revert to OnlineState.Unknown if the watch stream is not open and we
             // have no listeners, since without any listens to send we cannot
             // confirm if the stream is healthy and upgrade to OnlineState.Online.
-            remoteStoreImpl.onlineStateTracker.set("Unknown" /* Unknown */);
+            remoteStoreImpl.onlineStateTracker.set("Unknown" /* OnlineState.Unknown */);
         }
     }
 }
@@ -21655,14 +22216,14 @@ async function onWatchStreamClose(remoteStoreImpl, error) {
         // No need to restart watch stream because there are no active targets.
         // The online state is set to unknown because there is no active attempt
         // at establishing a connection
-        remoteStoreImpl.onlineStateTracker.set("Unknown" /* Unknown */);
+        remoteStoreImpl.onlineStateTracker.set("Unknown" /* OnlineState.Unknown */);
     }
 }
 async function onWatchStreamChange(remoteStoreImpl, watchChange, snapshotVersion) {
     // Mark the client as online since we got a message from the server
-    remoteStoreImpl.onlineStateTracker.set("Online" /* Online */);
+    remoteStoreImpl.onlineStateTracker.set("Online" /* OnlineState.Online */);
     if (watchChange instanceof WatchTargetChange &&
-        watchChange.state === 2 /* Removed */ &&
+        watchChange.state === 2 /* WatchTargetChangeState.Removed */ &&
         watchChange.cause) {
         // There was an error on a target, don't wait for a consistent snapshot
         // to raise events
@@ -21710,10 +22271,10 @@ async function onWatchStreamChange(remoteStoreImpl, watchChange, snapshotVersion
  */
 async function disableNetworkUntilRecovery(remoteStoreImpl, e, op) {
     if (isIndexedDbTransactionError(e)) {
-        remoteStoreImpl.offlineCauses.add(1 /* IndexedDbFailed */);
+        remoteStoreImpl.offlineCauses.add(1 /* OfflineCause.IndexedDbFailed */);
         // Disable network and raise offline snapshots
         await disableNetworkInternal(remoteStoreImpl);
-        remoteStoreImpl.onlineStateTracker.set("Offline" /* Offline */);
+        remoteStoreImpl.onlineStateTracker.set("Offline" /* OnlineState.Offline */);
         if (!op) {
             // Use a simple read operation to determine if IndexedDB recovered.
             // Ideally, we would expose a health check directly on SimpleDb, but
@@ -21724,7 +22285,7 @@ async function disableNetworkUntilRecovery(remoteStoreImpl, e, op) {
         remoteStoreImpl.asyncQueue.enqueueRetryable(async () => {
             logDebug(LOG_TAG$5, 'Retrying IndexedDB access');
             await op();
-            remoteStoreImpl.offlineCauses.delete(1 /* IndexedDbFailed */);
+            remoteStoreImpl.offlineCauses.delete(1 /* OfflineCause.IndexedDbFailed */);
             await enableNetworkInternal(remoteStoreImpl);
         });
     }
@@ -21775,7 +22336,7 @@ function raiseWatchSnapshot(remoteStoreImpl, snapshotVersion) {
         // mismatch, but don't actually retain that in listenTargets. This ensures
         // that we flag the first re-listen this way without impacting future
         // listens of this target (that might happen e.g. on reconnect).
-        const requestTargetData = new TargetData(targetData.target, targetId, 1 /* ExistenceFilterMismatch */, targetData.sequenceNumber);
+        const requestTargetData = new TargetData(targetData.target, targetId, 1 /* TargetPurpose.ExistenceFilterMismatch */, targetData.sequenceNumber);
         sendWatchRequest(remoteStoreImpl, requestTargetData);
     });
     return remoteStoreImpl.remoteSyncer.applyRemoteEvent(remoteEvent);
@@ -21906,10 +22467,10 @@ async function handleWriteError(remoteStoreImpl, error) {
 }
 async function restartNetwork(remoteStore) {
     const remoteStoreImpl = debugCast(remoteStore);
-    remoteStoreImpl.offlineCauses.add(4 /* ConnectivityChange */);
+    remoteStoreImpl.offlineCauses.add(4 /* OfflineCause.ConnectivityChange */);
     await disableNetworkInternal(remoteStoreImpl);
-    remoteStoreImpl.onlineStateTracker.set("Unknown" /* Unknown */);
-    remoteStoreImpl.offlineCauses.delete(4 /* ConnectivityChange */);
+    remoteStoreImpl.onlineStateTracker.set("Unknown" /* OnlineState.Unknown */);
+    remoteStoreImpl.offlineCauses.delete(4 /* OfflineCause.ConnectivityChange */);
     await enableNetworkInternal(remoteStoreImpl);
 }
 async function remoteStoreHandleCredentialChange(remoteStore, user) {
@@ -21920,14 +22481,14 @@ async function remoteStoreHandleCredentialChange(remoteStore, user) {
     // Tear down and re-create our network streams. This will ensure we get a
     // fresh auth token for the new user and re-fill the write pipeline with
     // new mutations from the LocalStore (since mutations are per-user).
-    remoteStoreImpl.offlineCauses.add(3 /* CredentialChange */);
+    remoteStoreImpl.offlineCauses.add(3 /* OfflineCause.CredentialChange */);
     await disableNetworkInternal(remoteStoreImpl);
     if (usesNetwork) {
         // Don't set the network status to Unknown if we are offline.
-        remoteStoreImpl.onlineStateTracker.set("Unknown" /* Unknown */);
+        remoteStoreImpl.onlineStateTracker.set("Unknown" /* OnlineState.Unknown */);
     }
     await remoteStoreImpl.remoteSyncer.handleCredentialChange(user);
-    remoteStoreImpl.offlineCauses.delete(3 /* CredentialChange */);
+    remoteStoreImpl.offlineCauses.delete(3 /* OfflineCause.CredentialChange */);
     await enableNetworkInternal(remoteStoreImpl);
 }
 /**
@@ -21936,13 +22497,13 @@ async function remoteStoreHandleCredentialChange(remoteStore, user) {
 async function remoteStoreApplyPrimaryState(remoteStore, isPrimary) {
     const remoteStoreImpl = debugCast(remoteStore);
     if (isPrimary) {
-        remoteStoreImpl.offlineCauses.delete(2 /* IsSecondary */);
+        remoteStoreImpl.offlineCauses.delete(2 /* OfflineCause.IsSecondary */);
         await enableNetworkInternal(remoteStoreImpl);
     }
     else if (!isPrimary) {
-        remoteStoreImpl.offlineCauses.add(2 /* IsSecondary */);
+        remoteStoreImpl.offlineCauses.add(2 /* OfflineCause.IsSecondary */);
         await disableNetworkInternal(remoteStoreImpl);
-        remoteStoreImpl.onlineStateTracker.set("Unknown" /* Unknown */);
+        remoteStoreImpl.onlineStateTracker.set("Unknown" /* OnlineState.Unknown */);
     }
 }
 /**
@@ -21968,7 +22529,7 @@ function ensureWatchStream(remoteStoreImpl) {
                     startWatchStream(remoteStoreImpl);
                 }
                 else {
-                    remoteStoreImpl.onlineStateTracker.set("Unknown" /* Unknown */);
+                    remoteStoreImpl.onlineStateTracker.set("Unknown" /* OnlineState.Unknown */);
                 }
             }
             else {
@@ -22299,46 +22860,46 @@ class DocumentChangeSet {
             return;
         }
         // Merge the new change with the existing change.
-        if (change.type !== 0 /* Added */ &&
-            oldChange.type === 3 /* Metadata */) {
+        if (change.type !== 0 /* ChangeType.Added */ &&
+            oldChange.type === 3 /* ChangeType.Metadata */) {
             this.changeMap = this.changeMap.insert(key, change);
         }
-        else if (change.type === 3 /* Metadata */ &&
-            oldChange.type !== 1 /* Removed */) {
+        else if (change.type === 3 /* ChangeType.Metadata */ &&
+            oldChange.type !== 1 /* ChangeType.Removed */) {
             this.changeMap = this.changeMap.insert(key, {
                 type: oldChange.type,
                 doc: change.doc
             });
         }
-        else if (change.type === 2 /* Modified */ &&
-            oldChange.type === 2 /* Modified */) {
+        else if (change.type === 2 /* ChangeType.Modified */ &&
+            oldChange.type === 2 /* ChangeType.Modified */) {
             this.changeMap = this.changeMap.insert(key, {
-                type: 2 /* Modified */,
+                type: 2 /* ChangeType.Modified */,
                 doc: change.doc
             });
         }
-        else if (change.type === 2 /* Modified */ &&
-            oldChange.type === 0 /* Added */) {
+        else if (change.type === 2 /* ChangeType.Modified */ &&
+            oldChange.type === 0 /* ChangeType.Added */) {
             this.changeMap = this.changeMap.insert(key, {
-                type: 0 /* Added */,
+                type: 0 /* ChangeType.Added */,
                 doc: change.doc
             });
         }
-        else if (change.type === 1 /* Removed */ &&
-            oldChange.type === 0 /* Added */) {
+        else if (change.type === 1 /* ChangeType.Removed */ &&
+            oldChange.type === 0 /* ChangeType.Added */) {
             this.changeMap = this.changeMap.remove(key);
         }
-        else if (change.type === 1 /* Removed */ &&
-            oldChange.type === 2 /* Modified */) {
+        else if (change.type === 1 /* ChangeType.Removed */ &&
+            oldChange.type === 2 /* ChangeType.Modified */) {
             this.changeMap = this.changeMap.insert(key, {
-                type: 1 /* Removed */,
+                type: 1 /* ChangeType.Removed */,
                 doc: oldChange.doc
             });
         }
-        else if (change.type === 0 /* Added */ &&
-            oldChange.type === 1 /* Removed */) {
+        else if (change.type === 0 /* ChangeType.Added */ &&
+            oldChange.type === 1 /* ChangeType.Removed */) {
             this.changeMap = this.changeMap.insert(key, {
-                type: 2 /* Modified */,
+                type: 2 /* ChangeType.Modified */,
                 doc: change.doc
             });
         }
@@ -22377,7 +22938,7 @@ class ViewSnapshot {
     static fromInitialDocuments(query, documents, mutatedKeys, fromCache, hasCachedResults) {
         const changes = [];
         documents.forEach(doc => {
-            changes.push({ type: 0 /* Added */, doc });
+            changes.push({ type: 0 /* ChangeType.Added */, doc });
         });
         return new ViewSnapshot(query, documents, DocumentSet.emptySet(documents), changes, mutatedKeys, fromCache, 
         /* syncStateChanged= */ true, 
@@ -22443,7 +23004,7 @@ function newEventManager() {
 class EventManagerImpl {
     constructor() {
         this.queries = new ObjectMap(q => canonifyQuery(q), queryEquals);
-        this.onlineState = "Unknown" /* Unknown */;
+        this.onlineState = "Unknown" /* OnlineState.Unknown */;
         this.snapshotsInSyncListeners = new Set();
     }
 }
@@ -22574,7 +23135,7 @@ class QueryListener {
          */
         this.raisedInitialEvent = false;
         this.snap = null;
-        this.onlineState = "Unknown" /* Unknown */;
+        this.onlineState = "Unknown" /* OnlineState.Unknown */;
         this.options = options || {};
     }
     /**
@@ -22588,7 +23149,7 @@ class QueryListener {
             // Remove the metadata only changes.
             const docChanges = [];
             for (const docChange of snap.docChanges) {
-                if (docChange.type !== 3 /* Metadata */) {
+                if (docChange.type !== 3 /* ChangeType.Metadata */) {
                     docChanges.push(docChange);
                 }
             }
@@ -22631,7 +23192,7 @@ class QueryListener {
         }
         // NOTE: We consider OnlineState.Unknown as online (it should become Offline
         // or Online if we wait long enough).
-        const maybeOnline = onlineState !== "Offline" /* Offline */;
+        const maybeOnline = onlineState !== "Offline" /* OnlineState.Offline */;
         // Don't raise the event if we're online, aren't synced yet (checked
         // above) and are waiting for a sync.
         if (this.options.waitForSyncWhenOnline && maybeOnline) {
@@ -22641,7 +23202,7 @@ class QueryListener {
         // or we are offline.
         return (!snap.docs.isEmpty() ||
             snap.hasCachedResults ||
-            onlineState === "Offline" /* Offline */);
+            onlineState === "Offline" /* OnlineState.Offline */);
     }
     shouldRaiseEvent(snap) {
         // We don't need to handle includeDocumentMetadataChanges here because
@@ -22700,10 +23261,10 @@ class LocalViewChanges {
         let removedKeys = documentKeySet();
         for (const docChange of viewSnapshot.docChanges) {
             switch (docChange.type) {
-                case 0 /* Added */:
+                case 0 /* ChangeType.Added */:
                     addedKeys = addedKeys.add(docChange.doc.key);
                     break;
-                case 1 /* Removed */:
+                case 1 /* ChangeType.Removed */:
                     removedKeys = removedKeys.add(docChange.doc.key);
                     break;
                 // do nothing
@@ -22951,11 +23512,11 @@ class View {
         //
         // Note that this should never get used in a refill (when previousChanges is
         // set), because there will only be adds -- no deletes or updates.
-        const lastDocInLimit = this.query.limitType === "F" /* First */ &&
+        const lastDocInLimit = this.query.limitType === "F" /* LimitType.First */ &&
             oldDocumentSet.size === this.query.limit
             ? oldDocumentSet.last()
             : null;
-        const firstDocInLimit = this.query.limitType === "L" /* Last */ &&
+        const firstDocInLimit = this.query.limitType === "L" /* LimitType.Last */ &&
             oldDocumentSet.size === this.query.limit
             ? oldDocumentSet.first()
             : null;
@@ -22978,7 +23539,7 @@ class View {
                 if (!docsEqual) {
                     if (!this.shouldWaitForSyncedDocument(oldDoc, newDoc)) {
                         changeSet.track({
-                            type: 2 /* Modified */,
+                            type: 2 /* ChangeType.Modified */,
                             doc: newDoc
                         });
                         changeApplied = true;
@@ -22994,16 +23555,16 @@ class View {
                     }
                 }
                 else if (oldDocHadPendingMutations !== newDocHasPendingMutations) {
-                    changeSet.track({ type: 3 /* Metadata */, doc: newDoc });
+                    changeSet.track({ type: 3 /* ChangeType.Metadata */, doc: newDoc });
                     changeApplied = true;
                 }
             }
             else if (!oldDoc && newDoc) {
-                changeSet.track({ type: 0 /* Added */, doc: newDoc });
+                changeSet.track({ type: 0 /* ChangeType.Added */, doc: newDoc });
                 changeApplied = true;
             }
             else if (oldDoc && !newDoc) {
-                changeSet.track({ type: 1 /* Removed */, doc: oldDoc });
+                changeSet.track({ type: 1 /* ChangeType.Removed */, doc: oldDoc });
                 changeApplied = true;
                 if (lastDocInLimit || firstDocInLimit) {
                     // A doc was removed from a full limit query. We'll need to
@@ -23031,12 +23592,12 @@ class View {
         // Drop documents out to meet limit/limitToLast requirement.
         if (this.query.limit !== null) {
             while (newDocumentSet.size > this.query.limit) {
-                const oldDoc = this.query.limitType === "F" /* First */
+                const oldDoc = this.query.limitType === "F" /* LimitType.First */
                     ? newDocumentSet.last()
                     : newDocumentSet.first();
                 newDocumentSet = newDocumentSet.delete(oldDoc.key);
                 newMutatedKeys = newMutatedKeys.delete(oldDoc.key);
-                changeSet.track({ type: 1 /* Removed */, doc: oldDoc });
+                changeSet.track({ type: 1 /* ChangeType.Removed */, doc: oldDoc });
             }
         }
         return {
@@ -23084,7 +23645,7 @@ class View {
             ? this.updateLimboDocuments()
             : [];
         const synced = this.limboDocuments.size === 0 && this.current;
-        const newSyncState = synced ? 1 /* Synced */ : 0 /* Local */;
+        const newSyncState = synced ? 1 /* SyncState.Synced */ : 0 /* SyncState.Local */;
         const syncStateChanged = newSyncState !== this.syncState;
         this.syncState = newSyncState;
         if (changes.length === 0 && !syncStateChanged) {
@@ -23092,7 +23653,7 @@ class View {
             return { limboChanges };
         }
         else {
-            const snap = new ViewSnapshot(this.query, docChanges.documentSet, oldDocs, changes, docChanges.mutatedKeys, newSyncState === 0 /* Local */, syncStateChanged, 
+            const snap = new ViewSnapshot(this.query, docChanges.documentSet, oldDocs, changes, docChanges.mutatedKeys, newSyncState === 0 /* SyncState.Local */, syncStateChanged, 
             /* excludesMetadataChanges= */ false, targetChange
                 ? targetChange.resumeToken.approximateByteSize() > 0
                 : false);
@@ -23107,7 +23668,7 @@ class View {
      * ViewChange if the view's syncState changes as a result.
      */
     applyOnlineStateChange(onlineState) {
-        if (this.current && onlineState === "Offline" /* Offline */) {
+        if (this.current && onlineState === "Offline" /* OnlineState.Offline */) {
             // If we're offline, set `current` to false and then call applyChanges()
             // to refresh our syncState and generate a ViewChange as appropriate. We
             // are guaranteed to get a new TargetChange that sets `current` back to
@@ -23222,22 +23783,22 @@ class View {
      */
     // PORTING NOTE: Multi-tab only.
     computeInitialSnapshot() {
-        return ViewSnapshot.fromInitialDocuments(this.query, this.documentSet, this.mutatedKeys, this.syncState === 0 /* Local */, this.hasCachedResults);
+        return ViewSnapshot.fromInitialDocuments(this.query, this.documentSet, this.mutatedKeys, this.syncState === 0 /* SyncState.Local */, this.hasCachedResults);
     }
 }
 function compareChangeType(c1, c2) {
     const order = (change) => {
         switch (change) {
-            case 0 /* Added */:
+            case 0 /* ChangeType.Added */:
                 return 1;
-            case 2 /* Modified */:
+            case 2 /* ChangeType.Modified */:
                 return 2;
-            case 3 /* Metadata */:
+            case 3 /* ChangeType.Metadata */:
                 // A metadata change is converted to a modified change at the public
                 // api layer.  Since we sort by document key and then change type,
                 // metadata and modified changes must be sorted equivalently.
                 return 2;
-            case 1 /* Removed */:
+            case 1 /* ChangeType.Removed */:
                 return 0;
             default:
                 return fail();
@@ -23355,7 +23916,7 @@ class SyncEngineImpl {
         /** Stores user callbacks waiting for all pending writes to be acknowledged. */
         this.pendingWritesCallbacks = new Map();
         this.limboTargetIdGenerator = TargetIdGenerator.forSyncEngine();
-        this.onlineState = "Unknown" /* Unknown */;
+        this.onlineState = "Unknown" /* OnlineState.Unknown */;
         // The primary state is set to `true` or `false` immediately after Firestore
         // startup. In the interim, a client should only be considered primary if
         // `isPrimary` is true.
@@ -23419,7 +23980,7 @@ async function initializeViewAndComputeSnapshot(syncEngineImpl, query, targetId,
     /* usePreviousResults= */ true);
     const view = new View(query, queryResult.remoteKeys);
     const viewDocChanges = view.computeDocChanges(queryResult.documents);
-    const synthesizedTargetChange = TargetChange.createSynthesizedTargetChangeForCurrentChange(targetId, current && syncEngineImpl.onlineState !== "Offline" /* Offline */, resumeToken);
+    const synthesizedTargetChange = TargetChange.createSynthesizedTargetChangeForCurrentChange(targetId, current && syncEngineImpl.onlineState !== "Offline" /* OnlineState.Offline */, resumeToken);
     const viewChange = view.applyChanges(viewDocChanges, 
     /* updateLimboDocuments= */ syncEngineImpl.isPrimaryClient, synthesizedTargetChange);
     updateTrackedLimbos(syncEngineImpl, targetId, viewChange.limboChanges);
@@ -23545,9 +24106,9 @@ function syncEngineApplyOnlineStateChange(syncEngine, onlineState, source) {
     // tab remains online) and only apply the primary tab's online state from
     // SharedClientState.
     if ((syncEngineImpl.isPrimaryClient &&
-        source === 0 /* RemoteStore */) ||
+        source === 0 /* OnlineStateSource.RemoteStore */) ||
         (!syncEngineImpl.isPrimaryClient &&
-            source === 1 /* SharedClientState */)) {
+            source === 1 /* OnlineStateSource.SharedClientState */)) {
         const newViewSnapshots = [];
         syncEngineImpl.queryViewsByQuery.forEach((query, queryView) => {
             const viewChange = queryView.view.applyOnlineStateChange(onlineState);
@@ -23815,7 +24376,7 @@ function pumpEnqueuedLimboResolutions(syncEngineImpl) {
         syncEngineImpl.activeLimboResolutionsByTarget.set(limboTargetId, new LimboResolution(key));
         syncEngineImpl.activeLimboTargetsByKey =
             syncEngineImpl.activeLimboTargetsByKey.insert(key, limboTargetId);
-        remoteStoreListen(syncEngineImpl.remoteStore, new TargetData(queryToTarget(newQueryForPath(key.path)), limboTargetId, 2 /* LimboResolution */, ListenSequence.INVALID));
+        remoteStoreListen(syncEngineImpl.remoteStore, new TargetData(queryToTarget(newQueryForPath(key.path)), limboTargetId, 2 /* TargetPurpose.LimboResolution */, ListenSequence.INVALID));
     }
 }
 async function syncEngineEmitNewSnapsAndNotifyLocalStore(syncEngine, changes, remoteEvent) {
@@ -24068,7 +24629,7 @@ async function synchronizeQueryViewsAndRaiseSnapshots(syncEngine, targets, trans
  */
 // PORTING NOTE: Multi-Tab only.
 function synthesizeTargetToQuery(target) {
-    return newQuery(target.path, target.collectionGroup, target.orderBy, target.filters, target.limit, "F" /* First */, target.startAt, target.endAt);
+    return newQuery(target.path, target.collectionGroup, target.orderBy, target.filters, target.limit, "F" /* LimitType.First */, target.startAt, target.endAt);
 }
 /** Returns the IDs of the clients that are currently active. */
 // PORTING NOTE: Multi-Tab only.
@@ -24399,7 +24960,7 @@ class OnlineComponentProvider {
         this.eventManager = this.createEventManager(cfg);
         this.syncEngine = this.createSyncEngine(cfg, 
         /* startAsPrimary=*/ !offlineComponentProvider.synchronizeTabs);
-        this.sharedClientState.onlineStateHandler = onlineState => syncEngineApplyOnlineStateChange(this.syncEngine, onlineState, 1 /* SharedClientState */);
+        this.sharedClientState.onlineStateHandler = onlineState => syncEngineApplyOnlineStateChange(this.syncEngine, onlineState, 1 /* OnlineStateSource.SharedClientState */);
         this.remoteStore.remoteSyncer.handleCredentialChange =
             syncEngineHandleCredentialChange.bind(null, this.syncEngine);
         await remoteStoreApplyPrimaryState(this.remoteStore, this.syncEngine.isPrimaryClient);
@@ -24413,7 +24974,7 @@ class OnlineComponentProvider {
         return newDatastore(cfg.authCredentials, cfg.appCheckCredentials, connection, serializer);
     }
     createRemoteStore(cfg) {
-        return newRemoteStore(this.localStore, this.datastore, cfg.asyncQueue, onlineState => syncEngineApplyOnlineStateChange(this.syncEngine, onlineState, 0 /* RemoteStore */), newConnectivityMonitor());
+        return newRemoteStore(this.localStore, this.datastore, cfg.asyncQueue, onlineState => syncEngineApplyOnlineStateChange(this.syncEngine, onlineState, 0 /* OnlineStateSource.RemoteStore */), newConnectivityMonitor());
     }
     createSyncEngine(cfg, startAsPrimary) {
         return newSyncEngine(this.localStore, this.remoteStore, this.eventManager, this.sharedClientState, cfg.initialUser, cfg.maxConcurrentLimboResolutions, startAsPrimary);
@@ -25170,7 +25731,7 @@ class TransactionRunner {
         this.updateFunction = updateFunction;
         this.deferred = deferred;
         this.attemptsRemaining = options.maxAttempts;
-        this.backoff = new ExponentialBackoff(this.asyncQueue, "transaction_retry" /* TransactionRetry */);
+        this.backoff = new ExponentialBackoff(this.asyncQueue, "transaction_retry" /* TimerId.TransactionRetry */);
     }
     /** Runs the transaction and sets the result on deferred. */
     run() {
@@ -26203,7 +26764,7 @@ class AsyncQueueImpl {
         // List of TimerIds to fast-forward delays for.
         this.timerIdsToSkip = [];
         // Backoff timer used to schedule retries for retryable operations
-        this.backoff = new ExponentialBackoff(this, "async_queue_retry" /* AsyncQueueRetry */);
+        this.backoff = new ExponentialBackoff(this, "async_queue_retry" /* TimerId.AsyncQueueRetry */);
         // Visibility handler that triggers an immediate retry of all retryable
         // operations. Meant to speed up recovery when we regain file system access
         // after page comes into foreground.
@@ -26373,7 +26934,7 @@ class AsyncQueueImpl {
             this.delayedOperations.sort((a, b) => a.targetTimeMs - b.targetTimeMs);
             for (const op of this.delayedOperations) {
                 op.skipDelay();
-                if (lastTimerId !== "all" /* All */ && op.timerId === lastTimerId) {
+                if (lastTimerId !== "all" /* TimerId.All */ && op.timerId === lastTimerId) {
                     break;
                 }
             }
@@ -27286,12 +27847,12 @@ class ParsedUpdateData {
 }
 function isWrite(dataSource) {
     switch (dataSource) {
-        case 0 /* Set */: // fall through
-        case 2 /* MergeSet */: // fall through
-        case 1 /* Update */:
+        case 0 /* UserDataSource.Set */: // fall through
+        case 2 /* UserDataSource.MergeSet */: // fall through
+        case 1 /* UserDataSource.Update */:
             return true;
-        case 3 /* Argument */:
-        case 4 /* ArrayArgument */:
+        case 3 /* UserDataSource.Argument */:
+        case 4 /* UserDataSource.ArrayArgument */:
             return false;
         default:
             throw fail();
@@ -27416,8 +27977,8 @@ function newUserDataReader(firestore) {
 /** Parse document data from a set() call. */
 function parseSetData(userDataReader, methodName, targetDoc, input, hasConverter, options = {}) {
     const context = userDataReader.createContext(options.merge || options.mergeFields
-        ? 2 /* MergeSet */
-        : 0 /* Set */, methodName, targetDoc, hasConverter);
+        ? 2 /* UserDataSource.MergeSet */
+        : 0 /* UserDataSource.Set */, methodName, targetDoc, hasConverter);
     validatePlainObject('Data must be an object, but it was:', context, input);
     const updateData = parseObject(input, context);
     let fieldMask;
@@ -27448,12 +28009,12 @@ function parseSetData(userDataReader, methodName, targetDoc, input, hasConverter
 }
 class DeleteFieldValueImpl extends FieldValue {
     _toFieldTransform(context) {
-        if (context.dataSource === 2 /* MergeSet */) {
+        if (context.dataSource === 2 /* UserDataSource.MergeSet */) {
             // No transform to add for a delete, but we need to add it to our
             // fieldMask so it gets deleted.
             context.fieldMask.push(context.path);
         }
-        else if (context.dataSource === 1 /* Update */) {
+        else if (context.dataSource === 1 /* UserDataSource.Update */) {
             throw context.createError(`${this._methodName}() can only appear at the top level ` +
                 'of your update data');
         }
@@ -27486,7 +28047,7 @@ class DeleteFieldValueImpl extends FieldValue {
  */
 function createSentinelChildContext(fieldValue, context, arrayElement) {
     return new ParseContextImpl({
-        dataSource: 3 /* Argument */,
+        dataSource: 3 /* UserDataSource.Argument */,
         targetDoc: context.settings.targetDoc,
         methodName: fieldValue._methodName,
         arrayElement
@@ -27550,7 +28111,7 @@ class NumericIncrementFieldValueImpl extends FieldValue {
 }
 /** Parse update data from an update() call. */
 function parseUpdateData(userDataReader, methodName, targetDoc, input) {
-    const context = userDataReader.createContext(1 /* Update */, methodName, targetDoc);
+    const context = userDataReader.createContext(1 /* UserDataSource.Update */, methodName, targetDoc);
     validatePlainObject('Data must be an object, but it was:', context, input);
     const fieldMaskPaths = [];
     const updateData = ObjectValue.empty();
@@ -27577,7 +28138,7 @@ function parseUpdateData(userDataReader, methodName, targetDoc, input) {
 }
 /** Parse update data from a list of field/value arguments. */
 function parseUpdateVarargs(userDataReader, methodName, targetDoc, field, value, moreFieldsAndValues) {
-    const context = userDataReader.createContext(1 /* Update */, methodName, targetDoc);
+    const context = userDataReader.createContext(1 /* UserDataSource.Update */, methodName, targetDoc);
     const keys = [fieldPathFromArgument$1(methodName, field, targetDoc)];
     const values = [value];
     if (moreFieldsAndValues.length % 2 !== 0) {
@@ -27624,7 +28185,7 @@ function parseUpdateVarargs(userDataReader, methodName, targetDoc, field, value,
  * contain additional arrays (e.g. the operand of an `in` query).
  */
 function parseQueryValue(userDataReader, methodName, input, allowArrays = false) {
-    const context = userDataReader.createContext(allowArrays ? 4 /* ArrayArgument */ : 3 /* Argument */, methodName);
+    const context = userDataReader.createContext(allowArrays ? 4 /* UserDataSource.ArrayArgument */ : 3 /* UserDataSource.Argument */, methodName);
     const parsed = parseData(input, context);
     return parsed;
 }
@@ -27674,7 +28235,7 @@ function parseData(input, context) {
             // contain additional arrays (each representing an individual field
             // value), so we disable this validation.
             if (context.settings.arrayElement &&
-                context.dataSource !== 4 /* ArrayArgument */) {
+                context.dataSource !== 4 /* UserDataSource.ArrayArgument */) {
                 throw context.createError('Nested arrays are not supported');
             }
             return parseArray(input, context);
@@ -28056,164 +28617,336 @@ function fieldPathFromArgument(methodName, arg) {
  * limitations under the License.
  */
 function validateHasExplicitOrderByForLimitToLast(query) {
-    if (query.limitType === "L" /* Last */ &&
+    if (query.limitType === "L" /* LimitType.Last */ &&
         query.explicitOrderBy.length === 0) {
         throw new FirestoreError(Code.UNIMPLEMENTED, 'limitToLast() queries require specifying at least one orderBy() clause');
     }
 }
+/**
+ * An `AppliableConstraint` is an abstraction of a constraint that can be applied
+ * to a Firestore query.
+ */
+class AppliableConstraint {
+}
 /**
  * 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`.
  */
-class QueryConstraint {
+class QueryConstraint extends AppliableConstraint {
 }
-/**
- * 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.
- */
-function query(query, ...queryConstraints) {
+function query(query, queryConstraint, ...additionalQueryConstraints) {
+    let queryConstraints = [];
+    if (queryConstraint instanceof AppliableConstraint) {
+        queryConstraints.push(queryConstraint);
+    }
+    queryConstraints = queryConstraints.concat(additionalQueryConstraints);
+    validateQueryConstraintArray(queryConstraints);
     for (const constraint of queryConstraints) {
         query = constraint._apply(query);
     }
     return query;
 }
-class QueryFilterConstraint extends QueryConstraint {
+/**
+ * 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`.
+ */
+class QueryFieldFilterConstraint extends QueryConstraint {
+    /**
+     * @internal
+     */
     constructor(_field, _op, _value) {
         super();
         this._field = _field;
         this._op = _op;
         this._value = _value;
+        /** The type of this query constraint */
         this.type = 'where';
     }
+    static _create(_field, _op, _value) {
+        return new QueryFieldFilterConstraint(_field, _op, _value);
+    }
     _apply(query) {
+        const filter = this._parse(query);
+        validateNewFieldFilter(query._query, filter);
+        return new Query(query.firestore, query.converter, queryWithAddedFilter(query._query, filter));
+    }
+    _parse(query) {
         const reader = newUserDataReader(query.firestore);
         const filter = newQueryFilter(query._query, 'where', reader, query.firestore._databaseId, this._field, this._op, this._value);
-        return new Query(query.firestore, query.converter, queryWithAddedFilter(query._query, filter));
+        return filter;
     }
 }
 /**
- * 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}.
  */
 function where(fieldPath, opStr, value) {
     const op = opStr;
     const field = fieldPathFromArgument('where', fieldPath);
-    return new QueryFilterConstraint(field, op, value);
+    return QueryFieldFilterConstraint._create(field, op, value);
+}
+/**
+ * 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
+ */
+class QueryCompositeFilterConstraint extends AppliableConstraint {
+    /**
+     * @internal
+     */
+    constructor(
+    /** The type of this query constraint */
+    type, _queryConstraints) {
+        super();
+        this.type = type;
+        this._queryConstraints = _queryConstraints;
+    }
+    static _create(type, _queryConstraints) {
+        return new QueryCompositeFilterConstraint(type, _queryConstraints);
+    }
+    _parse(query) {
+        const parsedFilters = this._queryConstraints
+            .map(queryConstraint => {
+            return queryConstraint._parse(query);
+        })
+            .filter(parsedFilter => parsedFilter.getFilters().length > 0);
+        if (parsedFilters.length === 1) {
+            return parsedFilters[0];
+        }
+        return CompositeFilter.create(parsedFilters, this._getOperator());
+    }
+    _apply(query) {
+        const parsedFilter = this._parse(query);
+        if (parsedFilter.getFilters().length === 0) {
+            // Return the existing query if not adding any more filters (e.g. an empty
+            // composite filter).
+            return query;
+        }
+        validateNewFilter(query._query, parsedFilter);
+        return new Query(query.firestore, query.converter, queryWithAddedFilter(query._query, parsedFilter));
+    }
+    _getQueryConstraints() {
+        return this._queryConstraints;
+    }
+    _getOperator() {
+        return this.type === 'and' ? "and" /* CompositeOperator.AND */ : "or" /* CompositeOperator.OR */;
+    }
+}
+/**
+ * Creates a new {@link QueryCompositeFilterConstraint} that is a disjunction of
+ * the given filter constraints. A disjunction filter includes a document if it
+ * satisfies any of the given filters.
+ *
+ * @param queryConstraints - Optional. The list of
+ * {@link QueryFilterConstraint}s to perform a disjunction for. These must be
+ * created with calls to {@link where}, {@link or}, or {@link and}.
+ * @returns The newly created {@link QueryCompositeFilterConstraint}.
+ * @internal TODO remove this internal tag with OR Query support in the server
+ */
+function or(...queryConstraints) {
+    // Only support QueryFilterConstraints
+    queryConstraints.forEach(queryConstraint => validateQueryFilterConstraint('or', queryConstraint));
+    return QueryCompositeFilterConstraint._create("or" /* CompositeOperator.OR */, queryConstraints);
+}
+/**
+ * Creates a new {@link QueryCompositeFilterConstraint} that is a conjunction of
+ * the given filter constraints. A conjunction filter includes a document if it
+ * satisfies all of the given filters.
+ *
+ * @param queryConstraints - Optional. The list of
+ * {@link QueryFilterConstraint}s to perform a conjunction for. These must be
+ * created with calls to {@link where}, {@link or}, or {@link and}.
+ * @returns The newly created {@link QueryCompositeFilterConstraint}.
+ * @internal TODO remove this internal tag with OR Query support in the server
+ */
+function and(...queryConstraints) {
+    // Only support QueryFilterConstraints
+    queryConstraints.forEach(queryConstraint => validateQueryFilterConstraint('and', queryConstraint));
+    return QueryCompositeFilterConstraint._create("and" /* CompositeOperator.AND */, queryConstraints);
 }
+/**
+ * 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.
+ */
 class QueryOrderByConstraint extends QueryConstraint {
+    /**
+     * @internal
+     */
     constructor(_field, _direction) {
         super();
         this._field = _field;
         this._direction = _direction;
+        /** The type of this query constraint */
         this.type = 'orderBy';
     }
+    static _create(_field, _direction) {
+        return new QueryOrderByConstraint(_field, _direction);
+    }
     _apply(query) {
         const orderBy = newQueryOrderBy(query._query, this._field, this._direction);
         return new Query(query.firestore, query.converter, queryWithAddedOrderBy(query._query, 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}.
  */
 function orderBy(fieldPath, directionStr = 'asc') {
     const direction = directionStr;
     const path = fieldPathFromArgument('orderBy', fieldPath);
-    return new QueryOrderByConstraint(path, direction);
+    return QueryOrderByConstraint._create(path, direction);
 }
+/**
+ * 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`.
+ */
 class QueryLimitConstraint extends QueryConstraint {
-    constructor(type, _limit, _limitType) {
+    /**
+     * @internal
+     */
+    constructor(
+    /** The type of this query constraint */
+    type, _limit, _limitType) {
         super();
         this.type = type;
         this._limit = _limit;
         this._limitType = _limitType;
     }
+    static _create(type, _limit, _limitType) {
+        return new QueryLimitConstraint(type, _limit, _limitType);
+    }
     _apply(query) {
         return new Query(query.firestore, query.converter, queryWithLimit(query._query, this._limit, this._limitType));
     }
 }
 /**
- * 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}.
  */
 function limit(limit) {
     validatePositiveNumber('limit', limit);
-    return new QueryLimitConstraint('limit', limit, "F" /* First */);
+    return QueryLimitConstraint._create('limit', limit, "F" /* LimitType.First */);
 }
 /**
- * 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}.
  */
 function limitToLast(limit) {
     validatePositiveNumber('limitToLast', limit);
-    return new QueryLimitConstraint('limitToLast', limit, "L" /* Last */);
+    return QueryLimitConstraint._create('limitToLast', limit, "L" /* LimitType.Last */);
 }
+/**
+ * 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`.
+ */
 class QueryStartAtConstraint extends QueryConstraint {
-    constructor(type, _docOrFields, _inclusive) {
+    /**
+     * @internal
+     */
+    constructor(
+    /** The type of this query constraint */
+    type, _docOrFields, _inclusive) {
         super();
         this.type = type;
         this._docOrFields = _docOrFields;
         this._inclusive = _inclusive;
     }
+    static _create(type, _docOrFields, _inclusive) {
+        return new QueryStartAtConstraint(type, _docOrFields, _inclusive);
+    }
     _apply(query) {
         const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._inclusive);
         return new Query(query.firestore, query.converter, queryWithStartAt(query._query, bound));
     }
 }
 function startAt(...docOrFields) {
-    return new QueryStartAtConstraint('startAt', docOrFields, 
+    return QueryStartAtConstraint._create('startAt', docOrFields, 
     /*inclusive=*/ true);
 }
 function startAfter(...docOrFields) {
-    return new QueryStartAtConstraint('startAfter', docOrFields, 
+    return QueryStartAtConstraint._create('startAfter', docOrFields, 
     /*inclusive=*/ false);
 }
+/**
+ * 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`.
+ */
 class QueryEndAtConstraint extends QueryConstraint {
-    constructor(type, _docOrFields, _inclusive) {
+    /**
+     * @internal
+     */
+    constructor(
+    /** The type of this query constraint */
+    type, _docOrFields, _inclusive) {
         super();
         this.type = type;
         this._docOrFields = _docOrFields;
         this._inclusive = _inclusive;
     }
+    static _create(type, _docOrFields, _inclusive) {
+        return new QueryEndAtConstraint(type, _docOrFields, _inclusive);
+    }
     _apply(query) {
         const bound = newQueryBoundFromDocOrFields(query, this.type, this._docOrFields, this._inclusive);
         return new Query(query.firestore, query.converter, queryWithEndAt(query._query, bound));
     }
 }
 function endBefore(...docOrFields) {
-    return new QueryEndAtConstraint('endBefore', docOrFields, 
+    return QueryEndAtConstraint._create('endBefore', docOrFields, 
     /*inclusive=*/ false);
 }
 function endAt(...docOrFields) {
-    return new QueryEndAtConstraint('endAt', docOrFields, /*inclusive=*/ true);
+    return QueryEndAtConstraint._create('endAt', docOrFields, 
+    /*inclusive=*/ true);
 }
 /** Helper function to create a bound from a document or fields */
 function newQueryBoundFromDocOrFields(query, methodName, docOrFields, inclusive) {
@@ -28229,10 +28962,10 @@ function newQueryBoundFromDocOrFields(query, methodName, docOrFields, inclusive)
 function newQueryFilter(query, methodName, dataReader, databaseId, fieldPath, op, value) {
     let fieldValue;
     if (fieldPath.isKeyField()) {
-        if (op === "array-contains" /* ARRAY_CONTAINS */ || op === "array-contains-any" /* ARRAY_CONTAINS_ANY */) {
+        if (op === "array-contains" /* Operator.ARRAY_CONTAINS */ || op === "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */) {
             throw new FirestoreError(Code.INVALID_ARGUMENT, `Invalid Query. You can't perform '${op}' queries on documentId().`);
         }
-        else if (op === "in" /* IN */ || op === "not-in" /* NOT_IN */) {
+        else if (op === "in" /* Operator.IN */ || op === "not-in" /* Operator.NOT_IN */) {
             validateDisjunctiveFilterElements(value, op);
             const referenceList = [];
             for (const arrayValue of value) {
@@ -28245,16 +28978,15 @@ function newQueryFilter(query, methodName, dataReader, databaseId, fieldPath, op
         }
     }
     else {
-        if (op === "in" /* IN */ ||
-            op === "not-in" /* NOT_IN */ ||
-            op === "array-contains-any" /* ARRAY_CONTAINS_ANY */) {
+        if (op === "in" /* Operator.IN */ ||
+            op === "not-in" /* Operator.NOT_IN */ ||
+            op === "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */) {
             validateDisjunctiveFilterElements(value, op);
         }
         fieldValue = parseQueryValue(dataReader, methodName, value, 
-        /* allowArrays= */ op === "in" /* IN */ || op === "not-in" /* NOT_IN */);
+        /* allowArrays= */ op === "in" /* Operator.IN */ || op === "not-in" /* Operator.NOT_IN */);
     }
     const filter = FieldFilter.create(fieldPath, op, fieldValue);
-    validateNewFilter(query, filter);
     return filter;
 }
 function newQueryOrderBy(query, fieldPath, direction) {
@@ -28424,62 +29156,84 @@ function validateDisjunctiveFilterElements(value, operator) {
  */
 function conflictingOps(op) {
     switch (op) {
-        case "!=" /* NOT_EQUAL */:
-            return ["!=" /* NOT_EQUAL */, "not-in" /* NOT_IN */];
-        case "array-contains" /* ARRAY_CONTAINS */:
+        case "!=" /* Operator.NOT_EQUAL */:
+            return ["!=" /* Operator.NOT_EQUAL */, "not-in" /* Operator.NOT_IN */];
+        case "array-contains" /* Operator.ARRAY_CONTAINS */:
             return [
-                "array-contains" /* ARRAY_CONTAINS */,
-                "array-contains-any" /* ARRAY_CONTAINS_ANY */,
-                "not-in" /* NOT_IN */
+                "array-contains" /* Operator.ARRAY_CONTAINS */,
+                "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */,
+                "not-in" /* Operator.NOT_IN */
             ];
-        case "in" /* IN */:
-            return ["array-contains-any" /* ARRAY_CONTAINS_ANY */, "in" /* IN */, "not-in" /* NOT_IN */];
-        case "array-contains-any" /* ARRAY_CONTAINS_ANY */:
+        case "in" /* Operator.IN */:
+            return ["array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */, "in" /* Operator.IN */, "not-in" /* Operator.NOT_IN */];
+        case "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */:
             return [
-                "array-contains" /* ARRAY_CONTAINS */,
-                "array-contains-any" /* ARRAY_CONTAINS_ANY */,
-                "in" /* IN */,
-                "not-in" /* NOT_IN */
+                "array-contains" /* Operator.ARRAY_CONTAINS */,
+                "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */,
+                "in" /* Operator.IN */,
+                "not-in" /* Operator.NOT_IN */
             ];
-        case "not-in" /* NOT_IN */:
+        case "not-in" /* Operator.NOT_IN */:
             return [
-                "array-contains" /* ARRAY_CONTAINS */,
-                "array-contains-any" /* ARRAY_CONTAINS_ANY */,
-                "in" /* IN */,
-                "not-in" /* NOT_IN */,
-                "!=" /* NOT_EQUAL */
+                "array-contains" /* Operator.ARRAY_CONTAINS */,
+                "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */,
+                "in" /* Operator.IN */,
+                "not-in" /* Operator.NOT_IN */,
+                "!=" /* Operator.NOT_EQUAL */
             ];
         default:
             return [];
     }
 }
-function validateNewFilter(query, filter) {
-    if (filter.isInequality()) {
-        const existingField = getInequalityFilterField(query);
-        if (existingField !== null && !existingField.isEqual(filter.field)) {
+function validateNewFieldFilter(query, fieldFilter) {
+    if (fieldFilter.isInequality()) {
+        const existingInequality = getInequalityFilterField(query);
+        const newInequality = fieldFilter.field;
+        if (existingInequality !== null &&
+            !existingInequality.isEqual(newInequality)) {
             throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid query. All where filters with an inequality' +
                 ' (<, <=, !=, not-in, >, or >=) must be on the same field. But you have' +
-                ` inequality filters on '${existingField.toString()}'` +
-                ` and '${filter.field.toString()}'`);
+                ` inequality filters on '${existingInequality.toString()}'` +
+                ` and '${newInequality.toString()}'`);
         }
         const firstOrderByField = getFirstOrderByField(query);
         if (firstOrderByField !== null) {
-            validateOrderByAndInequalityMatch(query, filter.field, firstOrderByField);
+            validateOrderByAndInequalityMatch(query, newInequality, firstOrderByField);
         }
     }
-    const conflictingOp = findFilterOperator(query, conflictingOps(filter.op));
+    const conflictingOp = findOpInsideFilters(query.filters, conflictingOps(fieldFilter.op));
     if (conflictingOp !== null) {
         // Special case when it's a duplicate op to give a slightly clearer error message.
-        if (conflictingOp === filter.op) {
+        if (conflictingOp === fieldFilter.op) {
             throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid query. You cannot use more than one ' +
-                `'${filter.op.toString()}' filter.`);
+                `'${fieldFilter.op.toString()}' filter.`);
         }
         else {
-            throw new FirestoreError(Code.INVALID_ARGUMENT, `Invalid query. You cannot use '${filter.op.toString()}' filters ` +
+            throw new FirestoreError(Code.INVALID_ARGUMENT, `Invalid query. You cannot use '${fieldFilter.op.toString()}' filters ` +
                 `with '${conflictingOp.toString()}' filters.`);
         }
     }
 }
+function validateNewFilter(query, filter) {
+    let testQuery = query;
+    const subFilters = filter.getFlattenedFilters();
+    for (const subFilter of subFilters) {
+        validateNewFieldFilter(testQuery, subFilter);
+        testQuery = queryWithAddedFilter(testQuery, subFilter);
+    }
+}
+// Checks if any of the provided filter operators are included in the given list of filters and
+// returns the first one that is, or null if none are.
+function findOpInsideFilters(filters, operators) {
+    for (const filter of filters) {
+        for (const fieldFilter of filter.getFlattenedFilters()) {
+            if (operators.indexOf(fieldFilter.op) >= 0) {
+                return fieldFilter.op;
+            }
+        }
+    }
+    return null;
+}
 function validateNewOrderBy(query, orderBy) {
     if (getFirstOrderByField(query) === null) {
         // This is the first order by. It must match any inequality.
@@ -28497,6 +29251,24 @@ function validateOrderByAndInequalityMatch(baseQuery, inequality, orderBy) {
             `as your first argument to orderBy(), but your first orderBy() ` +
             `is on field '${orderBy.toString()}' instead.`);
     }
+}
+function validateQueryFilterConstraint(functionName, queryConstraint) {
+    if (!(queryConstraint instanceof QueryFieldFilterConstraint) &&
+        !(queryConstraint instanceof QueryCompositeFilterConstraint)) {
+        throw new FirestoreError(Code.INVALID_ARGUMENT, `Function ${functionName}() requires AppliableConstraints created with a call to 'where(...)', 'or(...)', or 'and(...)'.`);
+    }
+}
+function validateQueryConstraintArray(queryConstraint) {
+    const compositeFilterCount = queryConstraint.filter(filter => filter instanceof QueryCompositeFilterConstraint).length;
+    const fieldFilterCount = queryConstraint.filter(filter => filter instanceof QueryFieldFilterConstraint).length;
+    if (compositeFilterCount > 1 ||
+        (compositeFilterCount > 0 && fieldFilterCount > 0)) {
+        throw new FirestoreError(Code.INVALID_ARGUMENT, 'InvalidQuery. When using composite filters, you cannot use ' +
+            'more than one filter at the top level. Consider nesting the multiple ' +
+            'filters within an `and(...)` statement. For example: ' +
+            'change `query(query, where(...), or(...))` to ' +
+            '`query(query, and(where(...), or(...)))`.');
+    }
 }
 
 /**
@@ -28524,27 +29296,27 @@ function validateOrderByAndInequalityMatch(baseQuery, inequality, orderBy) {
 class AbstractUserDataWriter {
     convertValue(value, serverTimestampBehavior = 'none') {
         switch (typeOrder(value)) {
-            case 0 /* NullValue */:
+            case 0 /* TypeOrder.NullValue */:
                 return null;
-            case 1 /* BooleanValue */:
+            case 1 /* TypeOrder.BooleanValue */:
                 return value.booleanValue;
-            case 2 /* NumberValue */:
+            case 2 /* TypeOrder.NumberValue */:
                 return normalizeNumber(value.integerValue || value.doubleValue);
-            case 3 /* TimestampValue */:
+            case 3 /* TypeOrder.TimestampValue */:
                 return this.convertTimestamp(value.timestampValue);
-            case 4 /* ServerTimestampValue */:
+            case 4 /* TypeOrder.ServerTimestampValue */:
                 return this.convertServerTimestamp(value, serverTimestampBehavior);
-            case 5 /* StringValue */:
+            case 5 /* TypeOrder.StringValue */:
                 return value.stringValue;
-            case 6 /* BlobValue */:
+            case 6 /* TypeOrder.BlobValue */:
                 return this.convertBytes(normalizeByteString(value.bytesValue));
-            case 7 /* RefValue */:
+            case 7 /* TypeOrder.RefValue */:
                 return this.convertReference(value.referenceValue);
-            case 8 /* GeoPointValue */:
+            case 8 /* TypeOrder.GeoPointValue */:
                 return this.convertGeoPoint(value.geoPointValue);
-            case 9 /* ArrayValue */:
+            case 9 /* TypeOrder.ArrayValue */:
                 return this.convertArray(value.arrayValue, serverTimestampBehavior);
-            case 10 /* ObjectValue */:
+            case 10 /* TypeOrder.ObjectValue */:
                 return this.convertObject(value.mapValue, serverTimestampBehavior);
             default:
                 throw fail();
@@ -28886,16 +29658,16 @@ function changesFromSnapshot(querySnapshot, includeMetadataChanges) {
         // to lookup the index of a document.
         let indexTracker = querySnapshot._snapshot.oldDocs;
         return querySnapshot._snapshot.docChanges
-            .filter(change => includeMetadataChanges || change.type !== 3 /* Metadata */)
+            .filter(change => includeMetadataChanges || change.type !== 3 /* ChangeType.Metadata */)
             .map(change => {
             const doc = new QueryDocumentSnapshot(querySnapshot._firestore, querySnapshot._userDataWriter, change.doc.key, change.doc, new SnapshotMetadata(querySnapshot._snapshot.mutatedKeys.has(change.doc.key), querySnapshot._snapshot.fromCache), querySnapshot.query.converter);
             let oldIndex = -1;
             let newIndex = -1;
-            if (change.type !== 0 /* Added */) {
+            if (change.type !== 0 /* ChangeType.Added */) {
                 oldIndex = indexTracker.indexOf(change.doc.key);
                 indexTracker = indexTracker.delete(change.doc.key);
             }
-            if (change.type !== 1 /* Removed */) {
+            if (change.type !== 1 /* ChangeType.Removed */) {
                 indexTracker = indexTracker.add(change.doc);
                 newIndex = indexTracker.indexOf(change.doc.key);
             }
@@ -28910,12 +29682,12 @@ function changesFromSnapshot(querySnapshot, includeMetadataChanges) {
 }
 function resultChangeType(type) {
     switch (type) {
-        case 0 /* Added */:
+        case 0 /* ChangeType.Added */:
             return 'added';
-        case 2 /* Modified */:
-        case 3 /* Metadata */:
+        case 2 /* ChangeType.Modified */:
+        case 3 /* ChangeType.Metadata */:
             return 'modified';
-        case 1 /* Removed */:
+        case 1 /* ChangeType.Removed */:
             return 'removed';
         default:
             return fail();
@@ -29045,7 +29817,8 @@ function getDocs(query) {
 }
 /**
  * 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.
  */
@@ -29749,13 +30522,13 @@ function parseIndexes(jsonOrConfiguration) {
                     const fieldPathString = tryGetString(field, 'fieldPath');
                     const fieldPath = fieldPathFromDotSeparatedString('setIndexConfiguration', fieldPathString);
                     if (field.arrayConfig === 'CONTAINS') {
-                        segments.push(new IndexSegment(fieldPath, 2 /* CONTAINS */));
+                        segments.push(new IndexSegment(fieldPath, 2 /* IndexKind.CONTAINS */));
                     }
                     else if (field.order === 'ASCENDING') {
-                        segments.push(new IndexSegment(fieldPath, 0 /* ASCENDING */));
+                        segments.push(new IndexSegment(fieldPath, 0 /* IndexKind.ASCENDING */));
                     }
                     else if (field.order === 'DESCENDING') {
-                        segments.push(new IndexSegment(fieldPath, 1 /* DESCENDING */));
+                        segments.push(new IndexSegment(fieldPath, 1 /* IndexKind.DESCENDING */));
                     }
                 }
             }
@@ -29765,12 +30538,11 @@ function parseIndexes(jsonOrConfiguration) {
     return parsedIndexes;
 }
 function tryParseJson(json) {
-    var _a;
     try {
         return JSON.parse(json);
     }
     catch (e) {
-        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Failed to parse JSON: ' + ((_a = e) === null || _a === void 0 ? void 0 : _a.message));
+        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Failed to parse JSON: ' + (e === null || e === void 0 ? void 0 : e.message));
     }
 }
 function tryGetString(data, property) {
@@ -29813,9 +30585,15 @@ exports.FirestoreError = FirestoreError;
 exports.GeoPoint = GeoPoint;
 exports.LoadBundleTask = LoadBundleTask;
 exports.Query = Query;
+exports.QueryCompositeFilterConstraint = QueryCompositeFilterConstraint;
 exports.QueryConstraint = QueryConstraint;
 exports.QueryDocumentSnapshot = QueryDocumentSnapshot;
+exports.QueryEndAtConstraint = QueryEndAtConstraint;
+exports.QueryFieldFilterConstraint = QueryFieldFilterConstraint;
+exports.QueryLimitConstraint = QueryLimitConstraint;
+exports.QueryOrderByConstraint = QueryOrderByConstraint;
 exports.QuerySnapshot = QuerySnapshot;
+exports.QueryStartAtConstraint = QueryStartAtConstraint;
 exports.SnapshotMetadata = SnapshotMetadata;
 exports.Timestamp = Timestamp;
 exports.Transaction = Transaction;
@@ -29832,6 +30610,7 @@ exports._logWarn = logWarn;
 exports._validateIsNotUsedTogether = validateIsNotUsedTogether;
 exports.addDoc = addDoc;
 exports.aggregateQuerySnapshotEqual = aggregateQuerySnapshotEqual;
+exports.and = and;
 exports.arrayRemove = arrayRemove;
 exports.arrayUnion = arrayUnion;
 exports.clearIndexedDbPersistence = clearIndexedDbPersistence;
@@ -29866,6 +30645,7 @@ exports.loadBundle = loadBundle;
 exports.namedQuery = namedQuery;
 exports.onSnapshot = onSnapshot;
 exports.onSnapshotsInSync = onSnapshotsInSync;
+exports.or = or;
 exports.orderBy = orderBy;
 exports.query = query;
 exports.queryEqual = queryEqual;