@firebase/firestore 3.7.3 → 3.8.0

package/dist/lite/index.node.cjs.js

@@ -14,7 +14,7 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var nodeFetch__default = /*#__PURE__*/_interopDefaultLegacy(nodeFetch);
 
-const version$1 = "3.7.3";
+const version$1 = "3.8.0";
 
 /**
  * @license
@@ -67,7 +67,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";
 
 /**
  * @license
@@ -1478,7 +1478,8 @@ class FetchConnection extends RestConnection {
                 body: requestJson
             });
         }
-        catch (err) {
+        catch (e) {
+            const err = e;
             throw new FirestoreError(mapCodeFromHttpStatus(err.status), 'Request failed with error: ' + err.statusText);
         }
         if (!response.ok) {
@@ -1612,159 +1613,29 @@ function arrayEquals(left, right, comparator) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// The earliest date supported by Firestore timestamps (0001-01-01T00:00:00Z).
-const MIN_SECONDS = -62135596800;
-// Number of nanoseconds in a millisecond.
-const MS_TO_NANOS = 1e6;
-/**
- * A `Timestamp` represents a point in time independent of any time zone or
- * calendar, represented as seconds and fractions of seconds at nanosecond
- * resolution in UTC Epoch time.
- *
- * It is encoded using the Proleptic Gregorian Calendar which extends the
- * Gregorian calendar backwards to year one. It is encoded assuming all minutes
- * are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second
- * table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to
- * 9999-12-31T23:59:59.999999999Z.
- *
- * For examples and further specifications, refer to the
- * {@link https://github.com/google/protobuf/blob/master/src/google/protobuf/timestamp.proto | Timestamp definition}.
- */
-class Timestamp {
-    /**
-     * Creates a new timestamp.
-     *
-     * @param seconds - The number of seconds of UTC time since Unix epoch
-     *     1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
-     *     9999-12-31T23:59:59Z inclusive.
-     * @param nanoseconds - The non-negative fractions of a second at nanosecond
-     *     resolution. Negative second values with fractions must still have
-     *     non-negative nanoseconds values that count forward in time. Must be
-     *     from 0 to 999,999,999 inclusive.
-     */
-    constructor(
-    /**
-     * The number of seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z.
-     */
-    seconds, 
-    /**
-     * The fractions of a second at nanosecond resolution.*
-     */
-    nanoseconds) {
-        this.seconds = seconds;
-        this.nanoseconds = nanoseconds;
-        if (nanoseconds < 0) {
-            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp nanoseconds out of range: ' + nanoseconds);
-        }
-        if (nanoseconds >= 1e9) {
-            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp nanoseconds out of range: ' + nanoseconds);
-        }
-        if (seconds < MIN_SECONDS) {
-            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp seconds out of range: ' + seconds);
-        }
-        // This will break in the year 10,000.
-        if (seconds >= 253402300800) {
-            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp seconds out of range: ' + seconds);
+function objectSize(obj) {
+    let count = 0;
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            count++;
         }
     }
-    /**
-     * Creates a new timestamp with the current date, with millisecond precision.
-     *
-     * @returns a new timestamp representing the current date.
-     */
-    static now() {
-        return Timestamp.fromMillis(Date.now());
-    }
-    /**
-     * Creates a new timestamp from the given date.
-     *
-     * @param date - The date to initialize the `Timestamp` from.
-     * @returns A new `Timestamp` representing the same point in time as the given
-     *     date.
-     */
-    static fromDate(date) {
-        return Timestamp.fromMillis(date.getTime());
-    }
-    /**
-     * Creates a new timestamp from the given number of milliseconds.
-     *
-     * @param milliseconds - Number of milliseconds since Unix epoch
-     *     1970-01-01T00:00:00Z.
-     * @returns A new `Timestamp` representing the same point in time as the given
-     *     number of milliseconds.
-     */
-    static fromMillis(milliseconds) {
-        const seconds = Math.floor(milliseconds / 1000);
-        const nanos = Math.floor((milliseconds - seconds * 1000) * MS_TO_NANOS);
-        return new Timestamp(seconds, nanos);
-    }
-    /**
-     * Converts a `Timestamp` to a JavaScript `Date` object. This conversion
-     * causes a loss of precision since `Date` objects only support millisecond
-     * precision.
-     *
-     * @returns JavaScript `Date` object representing the same point in time as
-     *     this `Timestamp`, with millisecond precision.
-     */
-    toDate() {
-        return new Date(this.toMillis());
-    }
-    /**
-     * Converts a `Timestamp` to a numeric timestamp (in milliseconds since
-     * epoch). This operation causes a loss of precision.
-     *
-     * @returns The point in time corresponding to this timestamp, represented as
-     *     the number of milliseconds since Unix epoch 1970-01-01T00:00:00Z.
-     */
-    toMillis() {
-        return this.seconds * 1000 + this.nanoseconds / MS_TO_NANOS;
-    }
-    _compareTo(other) {
-        if (this.seconds === other.seconds) {
-            return primitiveComparator(this.nanoseconds, other.nanoseconds);
+    return count;
+}
+function forEach(obj, fn) {
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            fn(key, obj[key]);
         }
-        return primitiveComparator(this.seconds, other.seconds);
-    }
-    /**
-     * Returns true if this `Timestamp` is equal to the provided one.
-     *
-     * @param other - The `Timestamp` to compare against.
-     * @returns true if this `Timestamp` is equal to the provided one.
-     */
-    isEqual(other) {
-        return (other.seconds === this.seconds && other.nanoseconds === this.nanoseconds);
-    }
-    /** Returns a textual representation of this `Timestamp`. */
-    toString() {
-        return ('Timestamp(seconds=' +
-            this.seconds +
-            ', nanoseconds=' +
-            this.nanoseconds +
-            ')');
-    }
-    /** Returns a JSON-serializable representation of this `Timestamp`. */
-    toJSON() {
-        return { seconds: this.seconds, nanoseconds: this.nanoseconds };
     }
-    /**
-     * Converts this object to a primitive string, which allows `Timestamp` objects
-     * to be compared using the `>`, `<=`, `>=` and `>` operators.
-     */
-    valueOf() {
-        // This method returns a string of the form <seconds>.<nanoseconds> where
-        // <seconds> is translated to have a non-negative value and both <seconds>
-        // and <nanoseconds> are left-padded with zeroes to be a consistent length.
-        // Strings with this format then have a lexiographical ordering that matches
-        // the expected ordering. The <seconds> translation is done to avoid having
-        // a leading negative sign (i.e. a leading '-' character) in its string
-        // representation, which would affect its lexiographical ordering.
-        const adjustedSeconds = this.seconds - MIN_SECONDS;
-        // Note: Up to 12 decimal digits are required to represent all valid
-        // 'seconds' values.
-        const formattedSeconds = String(adjustedSeconds).padStart(12, '0');
-        const formattedNanoseconds = String(this.nanoseconds).padStart(9, '0');
-        return formattedSeconds + '.' + formattedNanoseconds;
+}
+function isEmpty(obj) {
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            return false;
+        }
     }
+    return true;
 }
 
 /**
@@ -1784,44 +1655,32 @@ class Timestamp {
  * limitations under the License.
  */
 /**
- * A version of a document in Firestore. This corresponds to the version
- * timestamp, such as update_time or read_time.
+ * Returns whether a variable is either undefined or null.
  */
-class SnapshotVersion {
-    constructor(timestamp) {
-        this.timestamp = timestamp;
-    }
-    static fromTimestamp(value) {
-        return new SnapshotVersion(value);
-    }
-    static min() {
-        return new SnapshotVersion(new Timestamp(0, 0));
-    }
-    static max() {
-        return new SnapshotVersion(new Timestamp(253402300799, 1e9 - 1));
-    }
-    compareTo(other) {
-        return this.timestamp._compareTo(other.timestamp);
-    }
-    isEqual(other) {
-        return this.timestamp.isEqual(other.timestamp);
-    }
-    /** Returns a number representation of the version for use in spec tests. */
-    toMicroseconds() {
-        // Convert to microseconds.
-        return this.timestamp.seconds * 1e6 + this.timestamp.nanoseconds / 1000;
-    }
-    toString() {
-        return 'SnapshotVersion(' + this.timestamp.toString() + ')';
-    }
-    toTimestamp() {
-        return this.timestamp;
-    }
+function isNullOrUndefined(value) {
+    return value === null || value === undefined;
+}
+/** Returns whether the value represents -0. */
+function isNegativeZero(value) {
+    // Detect if the value is -0.0. Based on polyfill from
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+    return value === 0 && 1 / value === 1 / -0;
+}
+/**
+ * Returns whether a value is an integer and in the safe integer range
+ * @param value - The value to test for being an integer and in the safe range
+ */
+function isSafeInteger(value) {
+    return (typeof value === 'number' &&
+        Number.isInteger(value) &&
+        !isNegativeZero(value) &&
+        value <= Number.MAX_SAFE_INTEGER &&
+        value >= Number.MIN_SAFE_INTEGER);
 }
 
 /**
  * @license
- * Copyright 2017 Google LLC
+ * Copyright 2020 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -1835,34 +1694,20 @@ class SnapshotVersion {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function objectSize(obj) {
-    let count = 0;
-    for (const key in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, key)) {
-            count++;
-        }
-    }
-    return count;
-}
-function forEach(obj, fn) {
-    for (const key in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, key)) {
-            fn(key, obj[key]);
-        }
-    }
+/** Converts a Base64 encoded string to a binary string. */
+function decodeBase64(encoded) {
+    // Note: We used to validate the base64 string here via a regular expression.
+    // This was removed to improve the performance of indexing.
+    return Buffer.from(encoded, 'base64').toString('binary');
 }
-function isEmpty(obj) {
-    for (const key in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, key)) {
-            return false;
-        }
-    }
-    return true;
+/** Converts a binary string to a Base64 encoded string. */
+function encodeBase64(raw) {
+    return Buffer.from(raw, 'binary').toString('base64');
 }
 
 /**
  * @license
- * Copyright 2017 Google LLC
+ * Copyright 2020 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -1876,445 +1721,1165 @@ function isEmpty(obj) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// An immutable sorted map implementation, based on a Left-leaning Red-Black
-// tree.
-class SortedMap {
-    constructor(comparator, root) {
-        this.comparator = comparator;
-        this.root = root ? root : LLRBNode.EMPTY;
+/**
+ * Immutable class that represents a "proto" byte string.
+ *
+ * Proto byte strings can either be Base64-encoded strings or Uint8Arrays when
+ * sent on the wire. This class abstracts away this differentiation by holding
+ * the proto byte string in a common class that must be converted into a string
+ * before being sent as a proto.
+ * @internal
+ */
+class ByteString {
+    constructor(binaryString) {
+        this.binaryString = binaryString;
     }
-    // Returns a copy of the map, with the specified key/value added or replaced.
-    insert(key, value) {
-        return new SortedMap(this.comparator, this.root
-            .insert(key, value, this.comparator)
-            .copy(null, null, LLRBNode.BLACK, null, null));
+    static fromBase64String(base64) {
+        const binaryString = decodeBase64(base64);
+        return new ByteString(binaryString);
     }
-    // Returns a copy of the map, with the specified key removed.
-    remove(key) {
-        return new SortedMap(this.comparator, this.root
-            .remove(key, this.comparator)
-            .copy(null, null, LLRBNode.BLACK, null, null));
+    static fromUint8Array(array) {
+        // TODO(indexing); Remove the copy of the byte string here as this method
+        // is frequently called during indexing.
+        const binaryString = binaryStringFromUint8Array(array);
+        return new ByteString(binaryString);
     }
-    // Returns the value of the node with the given key, or null.
-    get(key) {
-        let node = this.root;
-        while (!node.isEmpty()) {
-            const cmp = this.comparator(key, node.key);
-            if (cmp === 0) {
-                return node.value;
-            }
-            else if (cmp < 0) {
-                node = node.left;
-            }
-            else if (cmp > 0) {
-                node = node.right;
+    [Symbol.iterator]() {
+        let i = 0;
+        return {
+            next: () => {
+                if (i < this.binaryString.length) {
+                    return { value: this.binaryString.charCodeAt(i++), done: false };
+                }
+                else {
+                    return { value: undefined, done: true };
+                }
             }
-        }
-        return null;
+        };
     }
-    // Returns the index of the element in this sorted map, or -1 if it doesn't
-    // exist.
-    indexOf(key) {
-        // Number of nodes that were pruned when descending right
-        let prunedNodes = 0;
-        let node = this.root;
-        while (!node.isEmpty()) {
-            const cmp = this.comparator(key, node.key);
-            if (cmp === 0) {
-                return prunedNodes + node.left.size;
-            }
-            else if (cmp < 0) {
-                node = node.left;
-            }
-            else {
-                // Count all nodes left of the node plus the node itself
-                prunedNodes += node.left.size + 1;
-                node = node.right;
-            }
-        }
-        // Node not found
-        return -1;
+    toBase64() {
+        return encodeBase64(this.binaryString);
     }
-    isEmpty() {
-        return this.root.isEmpty();
+    toUint8Array() {
+        return uint8ArrayFromBinaryString(this.binaryString);
     }
-    // Returns the total number of nodes in the map.
-    get size() {
-        return this.root.size;
+    approximateByteSize() {
+        return this.binaryString.length * 2;
     }
-    // Returns the minimum key in the map.
-    minKey() {
-        return this.root.minKey();
+    compareTo(other) {
+        return primitiveComparator(this.binaryString, other.binaryString);
     }
-    // Returns the maximum key in the map.
-    maxKey() {
-        return this.root.maxKey();
+    isEqual(other) {
+        return this.binaryString === other.binaryString;
     }
-    // Traverses the map in key order and calls the specified action function
-    // for each key/value pair. If action returns true, traversal is aborted.
-    // Returns the first truthy value returned by action, or the last falsey
-    // value returned by action.
-    inorderTraversal(action) {
-        return this.root.inorderTraversal(action);
+}
+ByteString.EMPTY_BYTE_STRING = new ByteString('');
+/**
+ * Helper function to convert an Uint8array to a binary string.
+ */
+function binaryStringFromUint8Array(array) {
+    let binaryString = '';
+    for (let i = 0; i < array.length; ++i) {
+        binaryString += String.fromCharCode(array[i]);
     }
-    forEach(fn) {
-        this.inorderTraversal((k, v) => {
-            fn(k, v);
-            return false;
-        });
+    return binaryString;
+}
+/**
+ * Helper function to convert a binary string to an Uint8Array.
+ */
+function uint8ArrayFromBinaryString(binaryString) {
+    const buffer = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        buffer[i] = binaryString.charCodeAt(i);
     }
-    toString() {
-        const descriptions = [];
-        this.inorderTraversal((k, v) => {
-            descriptions.push(`${k}:${v}`);
-            return false;
-        });
-        return `{${descriptions.join(', ')}}`;
+    return buffer;
+}
+
+/**
+ * @license
+ * Copyright 2020 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.
+ */
+// A RegExp matching ISO 8601 UTC timestamps with optional fraction.
+const ISO_TIMESTAMP_REG_EXP = new RegExp(/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.(\d+))?Z$/);
+/**
+ * Converts the possible Proto values for a timestamp value into a "seconds and
+ * nanos" representation.
+ */
+function normalizeTimestamp(date) {
+    hardAssert(!!date);
+    // The json interface (for the browser) will return an iso timestamp string,
+    // while the proto js library (for node) will return a
+    // google.protobuf.Timestamp instance.
+    if (typeof date === 'string') {
+        // The date string can have higher precision (nanos) than the Date class
+        // (millis), so we do some custom parsing here.
+        // Parse the nanos right out of the string.
+        let nanos = 0;
+        const fraction = ISO_TIMESTAMP_REG_EXP.exec(date);
+        hardAssert(!!fraction);
+        if (fraction[1]) {
+            // Pad the fraction out to 9 digits (nanos).
+            let nanoStr = fraction[1];
+            nanoStr = (nanoStr + '000000000').substr(0, 9);
+            nanos = Number(nanoStr);
+        }
+        // Parse the date to get the seconds.
+        const parsedDate = new Date(date);
+        const seconds = Math.floor(parsedDate.getTime() / 1000);
+        return { seconds, nanos };
     }
-    // Traverses the map in reverse key order and calls the specified action
-    // function for each key/value pair. If action returns true, traversal is
-    // aborted.
-    // Returns the first truthy value returned by action, or the last falsey
-    // value returned by action.
-    reverseTraversal(action) {
-        return this.root.reverseTraversal(action);
+    else {
+        // TODO(b/37282237): Use strings for Proto3 timestamps
+        // assert(!this.options.useProto3Json,
+        //   'The timestamp instance format requires Proto JS.');
+        const seconds = normalizeNumber(date.seconds);
+        const nanos = normalizeNumber(date.nanos);
+        return { seconds, nanos };
     }
-    // Returns an iterator over the SortedMap.
-    getIterator() {
-        return new SortedMapIterator(this.root, null, this.comparator, false);
+}
+/**
+ * Converts the possible Proto types for numbers into a JavaScript number.
+ * Returns 0 if the value is not numeric.
+ */
+function normalizeNumber(value) {
+    // TODO(bjornick): Handle int64 greater than 53 bits.
+    if (typeof value === 'number') {
+        return value;
     }
-    getIteratorFrom(key) {
-        return new SortedMapIterator(this.root, key, this.comparator, false);
+    else if (typeof value === 'string') {
+        return Number(value);
     }
-    getReverseIterator() {
-        return new SortedMapIterator(this.root, null, this.comparator, true);
+    else {
+        return 0;
     }
-    getReverseIteratorFrom(key) {
-        return new SortedMapIterator(this.root, key, this.comparator, true);
+}
+/** Converts the possible Proto types for Blobs into a ByteString. */
+function normalizeByteString(blob) {
+    if (typeof blob === 'string') {
+        return ByteString.fromBase64String(blob);
     }
-} // end SortedMap
-// An iterator over an LLRBNode.
-class SortedMapIterator {
-    constructor(node, startKey, comparator, isReverse) {
-        this.isReverse = isReverse;
-        this.nodeStack = [];
-        let cmp = 1;
-        while (!node.isEmpty()) {
-            cmp = startKey ? comparator(node.key, startKey) : 1;
-            // flip the comparison if we're going in reverse
-            if (startKey && isReverse) {
-                cmp *= -1;
-            }
-            if (cmp < 0) {
-                // This node is less than our start key. ignore it
-                if (this.isReverse) {
-                    node = node.left;
-                }
-                else {
-                    node = node.right;
-                }
-            }
-            else if (cmp === 0) {
-                // This node is exactly equal to our start key. Push it on the stack,
-                // but stop iterating;
-                this.nodeStack.push(node);
-                break;
-            }
-            else {
-                // This node is greater than our start key, add it to the stack and move
-                // to the next one
-                this.nodeStack.push(node);
-                if (this.isReverse) {
-                    node = node.right;
-                }
-                else {
-                    node = node.left;
-                }
-            }
+    else {
+        return ByteString.fromUint8Array(blob);
+    }
+}
+
+/**
+ * @license
+ * Copyright 2017 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.
+ */
+// The earliest date supported by Firestore timestamps (0001-01-01T00:00:00Z).
+const MIN_SECONDS = -62135596800;
+// Number of nanoseconds in a millisecond.
+const MS_TO_NANOS = 1e6;
+/**
+ * A `Timestamp` represents a point in time independent of any time zone or
+ * calendar, represented as seconds and fractions of seconds at nanosecond
+ * resolution in UTC Epoch time.
+ *
+ * It is encoded using the Proleptic Gregorian Calendar which extends the
+ * Gregorian calendar backwards to year one. It is encoded assuming all minutes
+ * are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second
+ * table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to
+ * 9999-12-31T23:59:59.999999999Z.
+ *
+ * For examples and further specifications, refer to the
+ * {@link https://github.com/google/protobuf/blob/master/src/google/protobuf/timestamp.proto | Timestamp definition}.
+ */
+class Timestamp {
+    /**
+     * Creates a new timestamp.
+     *
+     * @param seconds - The number of seconds of UTC time since Unix epoch
+     *     1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+     *     9999-12-31T23:59:59Z inclusive.
+     * @param nanoseconds - The non-negative fractions of a second at nanosecond
+     *     resolution. Negative second values with fractions must still have
+     *     non-negative nanoseconds values that count forward in time. Must be
+     *     from 0 to 999,999,999 inclusive.
+     */
+    constructor(
+    /**
+     * The number of seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z.
+     */
+    seconds, 
+    /**
+     * The fractions of a second at nanosecond resolution.*
+     */
+    nanoseconds) {
+        this.seconds = seconds;
+        this.nanoseconds = nanoseconds;
+        if (nanoseconds < 0) {
+            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp nanoseconds out of range: ' + nanoseconds);
+        }
+        if (nanoseconds >= 1e9) {
+            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp nanoseconds out of range: ' + nanoseconds);
+        }
+        if (seconds < MIN_SECONDS) {
+            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp seconds out of range: ' + seconds);
+        }
+        // This will break in the year 10,000.
+        if (seconds >= 253402300800) {
+            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Timestamp seconds out of range: ' + seconds);
         }
     }
-    getNext() {
-        let node = this.nodeStack.pop();
-        const result = { key: node.key, value: node.value };
-        if (this.isReverse) {
-            node = node.left;
-            while (!node.isEmpty()) {
-                this.nodeStack.push(node);
-                node = node.right;
+    /**
+     * Creates a new timestamp with the current date, with millisecond precision.
+     *
+     * @returns a new timestamp representing the current date.
+     */
+    static now() {
+        return Timestamp.fromMillis(Date.now());
+    }
+    /**
+     * Creates a new timestamp from the given date.
+     *
+     * @param date - The date to initialize the `Timestamp` from.
+     * @returns A new `Timestamp` representing the same point in time as the given
+     *     date.
+     */
+    static fromDate(date) {
+        return Timestamp.fromMillis(date.getTime());
+    }
+    /**
+     * Creates a new timestamp from the given number of milliseconds.
+     *
+     * @param milliseconds - Number of milliseconds since Unix epoch
+     *     1970-01-01T00:00:00Z.
+     * @returns A new `Timestamp` representing the same point in time as the given
+     *     number of milliseconds.
+     */
+    static fromMillis(milliseconds) {
+        const seconds = Math.floor(milliseconds / 1000);
+        const nanos = Math.floor((milliseconds - seconds * 1000) * MS_TO_NANOS);
+        return new Timestamp(seconds, nanos);
+    }
+    /**
+     * Converts a `Timestamp` to a JavaScript `Date` object. This conversion
+     * causes a loss of precision since `Date` objects only support millisecond
+     * precision.
+     *
+     * @returns JavaScript `Date` object representing the same point in time as
+     *     this `Timestamp`, with millisecond precision.
+     */
+    toDate() {
+        return new Date(this.toMillis());
+    }
+    /**
+     * Converts a `Timestamp` to a numeric timestamp (in milliseconds since
+     * epoch). This operation causes a loss of precision.
+     *
+     * @returns The point in time corresponding to this timestamp, represented as
+     *     the number of milliseconds since Unix epoch 1970-01-01T00:00:00Z.
+     */
+    toMillis() {
+        return this.seconds * 1000 + this.nanoseconds / MS_TO_NANOS;
+    }
+    _compareTo(other) {
+        if (this.seconds === other.seconds) {
+            return primitiveComparator(this.nanoseconds, other.nanoseconds);
+        }
+        return primitiveComparator(this.seconds, other.seconds);
+    }
+    /**
+     * Returns true if this `Timestamp` is equal to the provided one.
+     *
+     * @param other - The `Timestamp` to compare against.
+     * @returns true if this `Timestamp` is equal to the provided one.
+     */
+    isEqual(other) {
+        return (other.seconds === this.seconds && other.nanoseconds === this.nanoseconds);
+    }
+    /** Returns a textual representation of this `Timestamp`. */
+    toString() {
+        return ('Timestamp(seconds=' +
+            this.seconds +
+            ', nanoseconds=' +
+            this.nanoseconds +
+            ')');
+    }
+    /** Returns a JSON-serializable representation of this `Timestamp`. */
+    toJSON() {
+        return { seconds: this.seconds, nanoseconds: this.nanoseconds };
+    }
+    /**
+     * Converts this object to a primitive string, which allows `Timestamp` objects
+     * to be compared using the `>`, `<=`, `>=` and `>` operators.
+     */
+    valueOf() {
+        // This method returns a string of the form <seconds>.<nanoseconds> where
+        // <seconds> is translated to have a non-negative value and both <seconds>
+        // and <nanoseconds> are left-padded with zeroes to be a consistent length.
+        // Strings with this format then have a lexiographical ordering that matches
+        // the expected ordering. The <seconds> translation is done to avoid having
+        // a leading negative sign (i.e. a leading '-' character) in its string
+        // representation, which would affect its lexiographical ordering.
+        const adjustedSeconds = this.seconds - MIN_SECONDS;
+        // Note: Up to 12 decimal digits are required to represent all valid
+        // 'seconds' values.
+        const formattedSeconds = String(adjustedSeconds).padStart(12, '0');
+        const formattedNanoseconds = String(this.nanoseconds).padStart(9, '0');
+        return formattedSeconds + '.' + formattedNanoseconds;
+    }
+}
+
+/**
+ * @license
+ * Copyright 2020 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.
+ */
+/**
+ * Represents a locally-applied ServerTimestamp.
+ *
+ * Server Timestamps are backed by MapValues that contain an internal field
+ * `__type__` with a value of `server_timestamp`. The previous value and local
+ * write time are stored in its `__previous_value__` and `__local_write_time__`
+ * fields respectively.
+ *
+ * Notes:
+ * - ServerTimestampValue instances are created as the result of applying a
+ *   transform. They can only exist in the local view of a document. Therefore
+ *   they do not need to be parsed or serialized.
+ * - When evaluated locally (e.g. for snapshot.data()), they by default
+ *   evaluate to `null`. This behavior can be configured by passing custom
+ *   FieldValueOptions to value().
+ * - With respect to other ServerTimestampValues, they sort by their
+ *   localWriteTime.
+ */
+const SERVER_TIMESTAMP_SENTINEL = 'server_timestamp';
+const TYPE_KEY = '__type__';
+const PREVIOUS_VALUE_KEY = '__previous_value__';
+const LOCAL_WRITE_TIME_KEY = '__local_write_time__';
+function isServerTimestamp(value) {
+    var _a, _b;
+    const type = (_b = (((_a = value === null || value === void 0 ? void 0 : value.mapValue) === null || _a === void 0 ? void 0 : _a.fields) || {})[TYPE_KEY]) === null || _b === void 0 ? void 0 : _b.stringValue;
+    return type === SERVER_TIMESTAMP_SENTINEL;
+}
+/**
+ * Returns the value of the field before this ServerTimestamp was set.
+ *
+ * Preserving the previous values allows the user to display the last resoled
+ * value until the backend responds with the timestamp.
+ */
+function getPreviousValue(value) {
+    const previousValue = value.mapValue.fields[PREVIOUS_VALUE_KEY];
+    if (isServerTimestamp(previousValue)) {
+        return getPreviousValue(previousValue);
+    }
+    return previousValue;
+}
+/**
+ * Returns the local time at which this timestamp was first set.
+ */
+function getLocalWriteTime(value) {
+    const localWriteTime = normalizeTimestamp(value.mapValue.fields[LOCAL_WRITE_TIME_KEY].timestampValue);
+    return new Timestamp(localWriteTime.seconds, localWriteTime.nanos);
+}
+
+/**
+ * @license
+ * Copyright 2020 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.
+ */
+const MAX_VALUE_TYPE = '__max__';
+const MAX_VALUE = {
+    mapValue: {
+        fields: {
+            '__type__': { stringValue: MAX_VALUE_TYPE }
+        }
+    }
+};
+/** Extracts the backend's type order for the provided value. */
+function typeOrder(value) {
+    if ('nullValue' in value) {
+        return 0 /* TypeOrder.NullValue */;
+    }
+    else if ('booleanValue' in value) {
+        return 1 /* TypeOrder.BooleanValue */;
+    }
+    else if ('integerValue' in value || 'doubleValue' in value) {
+        return 2 /* TypeOrder.NumberValue */;
+    }
+    else if ('timestampValue' in value) {
+        return 3 /* TypeOrder.TimestampValue */;
+    }
+    else if ('stringValue' in value) {
+        return 5 /* TypeOrder.StringValue */;
+    }
+    else if ('bytesValue' in value) {
+        return 6 /* TypeOrder.BlobValue */;
+    }
+    else if ('referenceValue' in value) {
+        return 7 /* TypeOrder.RefValue */;
+    }
+    else if ('geoPointValue' in value) {
+        return 8 /* TypeOrder.GeoPointValue */;
+    }
+    else if ('arrayValue' in value) {
+        return 9 /* TypeOrder.ArrayValue */;
+    }
+    else if ('mapValue' in value) {
+        if (isServerTimestamp(value)) {
+            return 4 /* TypeOrder.ServerTimestampValue */;
+        }
+        else if (isMaxValue(value)) {
+            return 9007199254740991 /* TypeOrder.MaxValue */;
+        }
+        return 10 /* TypeOrder.ObjectValue */;
+    }
+    else {
+        return fail();
+    }
+}
+/** Tests `left` and `right` for equality based on the backend semantics. */
+function valueEquals(left, right) {
+    if (left === right) {
+        return true;
+    }
+    const leftType = typeOrder(left);
+    const rightType = typeOrder(right);
+    if (leftType !== rightType) {
+        return false;
+    }
+    switch (leftType) {
+        case 0 /* TypeOrder.NullValue */:
+            return true;
+        case 1 /* TypeOrder.BooleanValue */:
+            return left.booleanValue === right.booleanValue;
+        case 4 /* TypeOrder.ServerTimestampValue */:
+            return getLocalWriteTime(left).isEqual(getLocalWriteTime(right));
+        case 3 /* TypeOrder.TimestampValue */:
+            return timestampEquals(left, right);
+        case 5 /* TypeOrder.StringValue */:
+            return left.stringValue === right.stringValue;
+        case 6 /* TypeOrder.BlobValue */:
+            return blobEquals(left, right);
+        case 7 /* TypeOrder.RefValue */:
+            return left.referenceValue === right.referenceValue;
+        case 8 /* TypeOrder.GeoPointValue */:
+            return geoPointEquals(left, right);
+        case 2 /* TypeOrder.NumberValue */:
+            return numberEquals(left, right);
+        case 9 /* TypeOrder.ArrayValue */:
+            return arrayEquals(left.arrayValue.values || [], right.arrayValue.values || [], valueEquals);
+        case 10 /* TypeOrder.ObjectValue */:
+            return objectEquals(left, right);
+        case 9007199254740991 /* TypeOrder.MaxValue */:
+            return true;
+        default:
+            return fail();
+    }
+}
+function timestampEquals(left, right) {
+    if (typeof left.timestampValue === 'string' &&
+        typeof right.timestampValue === 'string' &&
+        left.timestampValue.length === right.timestampValue.length) {
+        // Use string equality for ISO 8601 timestamps
+        return left.timestampValue === right.timestampValue;
+    }
+    const leftTimestamp = normalizeTimestamp(left.timestampValue);
+    const rightTimestamp = normalizeTimestamp(right.timestampValue);
+    return (leftTimestamp.seconds === rightTimestamp.seconds &&
+        leftTimestamp.nanos === rightTimestamp.nanos);
+}
+function geoPointEquals(left, right) {
+    return (normalizeNumber(left.geoPointValue.latitude) ===
+        normalizeNumber(right.geoPointValue.latitude) &&
+        normalizeNumber(left.geoPointValue.longitude) ===
+            normalizeNumber(right.geoPointValue.longitude));
+}
+function blobEquals(left, right) {
+    return normalizeByteString(left.bytesValue).isEqual(normalizeByteString(right.bytesValue));
+}
+function numberEquals(left, right) {
+    if ('integerValue' in left && 'integerValue' in right) {
+        return (normalizeNumber(left.integerValue) === normalizeNumber(right.integerValue));
+    }
+    else if ('doubleValue' in left && 'doubleValue' in right) {
+        const n1 = normalizeNumber(left.doubleValue);
+        const n2 = normalizeNumber(right.doubleValue);
+        if (n1 === n2) {
+            return isNegativeZero(n1) === isNegativeZero(n2);
+        }
+        else {
+            return isNaN(n1) && isNaN(n2);
+        }
+    }
+    return false;
+}
+function objectEquals(left, right) {
+    const leftMap = left.mapValue.fields || {};
+    const rightMap = right.mapValue.fields || {};
+    if (objectSize(leftMap) !== objectSize(rightMap)) {
+        return false;
+    }
+    for (const key in leftMap) {
+        if (leftMap.hasOwnProperty(key)) {
+            if (rightMap[key] === undefined ||
+                !valueEquals(leftMap[key], rightMap[key])) {
+                return false;
             }
         }
-        else {
-            node = node.right;
-            while (!node.isEmpty()) {
-                this.nodeStack.push(node);
-                node = node.left;
-            }
+    }
+    return true;
+}
+/** Returns true if the ArrayValue contains the specified element. */
+function arrayValueContains(haystack, needle) {
+    return ((haystack.values || []).find(v => valueEquals(v, needle)) !== undefined);
+}
+function valueCompare(left, right) {
+    if (left === right) {
+        return 0;
+    }
+    const leftType = typeOrder(left);
+    const rightType = typeOrder(right);
+    if (leftType !== rightType) {
+        return primitiveComparator(leftType, rightType);
+    }
+    switch (leftType) {
+        case 0 /* TypeOrder.NullValue */:
+        case 9007199254740991 /* TypeOrder.MaxValue */:
+            return 0;
+        case 1 /* TypeOrder.BooleanValue */:
+            return primitiveComparator(left.booleanValue, right.booleanValue);
+        case 2 /* TypeOrder.NumberValue */:
+            return compareNumbers(left, right);
+        case 3 /* TypeOrder.TimestampValue */:
+            return compareTimestamps(left.timestampValue, right.timestampValue);
+        case 4 /* TypeOrder.ServerTimestampValue */:
+            return compareTimestamps(getLocalWriteTime(left), getLocalWriteTime(right));
+        case 5 /* TypeOrder.StringValue */:
+            return primitiveComparator(left.stringValue, right.stringValue);
+        case 6 /* TypeOrder.BlobValue */:
+            return compareBlobs(left.bytesValue, right.bytesValue);
+        case 7 /* TypeOrder.RefValue */:
+            return compareReferences(left.referenceValue, right.referenceValue);
+        case 8 /* TypeOrder.GeoPointValue */:
+            return compareGeoPoints(left.geoPointValue, right.geoPointValue);
+        case 9 /* TypeOrder.ArrayValue */:
+            return compareArrays(left.arrayValue, right.arrayValue);
+        case 10 /* TypeOrder.ObjectValue */:
+            return compareMaps(left.mapValue, right.mapValue);
+        default:
+            throw fail();
+    }
+}
+function compareNumbers(left, right) {
+    const leftNumber = normalizeNumber(left.integerValue || left.doubleValue);
+    const rightNumber = normalizeNumber(right.integerValue || right.doubleValue);
+    if (leftNumber < rightNumber) {
+        return -1;
+    }
+    else if (leftNumber > rightNumber) {
+        return 1;
+    }
+    else if (leftNumber === rightNumber) {
+        return 0;
+    }
+    else {
+        // one or both are NaN.
+        if (isNaN(leftNumber)) {
+            return isNaN(rightNumber) ? 0 : -1;
+        }
+        else {
+            return 1;
+        }
+    }
+}
+function compareTimestamps(left, right) {
+    if (typeof left === 'string' &&
+        typeof right === 'string' &&
+        left.length === right.length) {
+        return primitiveComparator(left, right);
+    }
+    const leftTimestamp = normalizeTimestamp(left);
+    const rightTimestamp = normalizeTimestamp(right);
+    const comparison = primitiveComparator(leftTimestamp.seconds, rightTimestamp.seconds);
+    if (comparison !== 0) {
+        return comparison;
+    }
+    return primitiveComparator(leftTimestamp.nanos, rightTimestamp.nanos);
+}
+function compareReferences(leftPath, rightPath) {
+    const leftSegments = leftPath.split('/');
+    const rightSegments = rightPath.split('/');
+    for (let i = 0; i < leftSegments.length && i < rightSegments.length; i++) {
+        const comparison = primitiveComparator(leftSegments[i], rightSegments[i]);
+        if (comparison !== 0) {
+            return comparison;
+        }
+    }
+    return primitiveComparator(leftSegments.length, rightSegments.length);
+}
+function compareGeoPoints(left, right) {
+    const comparison = primitiveComparator(normalizeNumber(left.latitude), normalizeNumber(right.latitude));
+    if (comparison !== 0) {
+        return comparison;
+    }
+    return primitiveComparator(normalizeNumber(left.longitude), normalizeNumber(right.longitude));
+}
+function compareBlobs(left, right) {
+    const leftBytes = normalizeByteString(left);
+    const rightBytes = normalizeByteString(right);
+    return leftBytes.compareTo(rightBytes);
+}
+function compareArrays(left, right) {
+    const leftArray = left.values || [];
+    const rightArray = right.values || [];
+    for (let i = 0; i < leftArray.length && i < rightArray.length; ++i) {
+        const compare = valueCompare(leftArray[i], rightArray[i]);
+        if (compare) {
+            return compare;
+        }
+    }
+    return primitiveComparator(leftArray.length, rightArray.length);
+}
+function compareMaps(left, right) {
+    if (left === MAX_VALUE.mapValue && right === MAX_VALUE.mapValue) {
+        return 0;
+    }
+    else if (left === MAX_VALUE.mapValue) {
+        return 1;
+    }
+    else if (right === MAX_VALUE.mapValue) {
+        return -1;
+    }
+    const leftMap = left.fields || {};
+    const leftKeys = Object.keys(leftMap);
+    const rightMap = right.fields || {};
+    const rightKeys = Object.keys(rightMap);
+    // Even though MapValues are likely sorted correctly based on their insertion
+    // order (e.g. when received from the backend), local modifications can bring
+    // elements out of order. We need to re-sort the elements to ensure that
+    // canonical IDs are independent of insertion order.
+    leftKeys.sort();
+    rightKeys.sort();
+    for (let i = 0; i < leftKeys.length && i < rightKeys.length; ++i) {
+        const keyCompare = primitiveComparator(leftKeys[i], rightKeys[i]);
+        if (keyCompare !== 0) {
+            return keyCompare;
+        }
+        const compare = valueCompare(leftMap[leftKeys[i]], rightMap[rightKeys[i]]);
+        if (compare !== 0) {
+            return compare;
         }
-        return result;
-    }
-    hasNext() {
-        return this.nodeStack.length > 0;
     }
-    peek() {
-        if (this.nodeStack.length === 0) {
-            return null;
-        }
-        const node = this.nodeStack[this.nodeStack.length - 1];
-        return { key: node.key, value: node.value };
+    return primitiveComparator(leftKeys.length, rightKeys.length);
+}
+/** Returns a reference value for the provided database and key. */
+function refValue(databaseId, key) {
+    return {
+        referenceValue: `projects/${databaseId.projectId}/databases/${databaseId.database}/documents/${key.path.canonicalString()}`
+    };
+}
+/** Returns true if `value` is an ArrayValue. */
+function isArray(value) {
+    return !!value && 'arrayValue' in value;
+}
+/** Returns true if `value` is a NullValue. */
+function isNullValue(value) {
+    return !!value && 'nullValue' in value;
+}
+/** Returns true if `value` is NaN. */
+function isNanValue(value) {
+    return !!value && 'doubleValue' in value && isNaN(Number(value.doubleValue));
+}
+/** Returns true if `value` is a MapValue. */
+function isMapValue(value) {
+    return !!value && 'mapValue' in value;
+}
+/** Creates a deep copy of `source`. */
+function deepClone(source) {
+    if (source.geoPointValue) {
+        return { geoPointValue: Object.assign({}, source.geoPointValue) };
     }
-} // end SortedMapIterator
-// Represents a node in a Left-leaning Red-Black tree.
-class LLRBNode {
-    constructor(key, value, color, left, right) {
-        this.key = key;
-        this.value = value;
-        this.color = color != null ? color : LLRBNode.RED;
-        this.left = left != null ? left : LLRBNode.EMPTY;
-        this.right = right != null ? right : LLRBNode.EMPTY;
-        this.size = this.left.size + 1 + this.right.size;
+    else if (source.timestampValue &&
+        typeof source.timestampValue === 'object') {
+        return { timestampValue: Object.assign({}, source.timestampValue) };
     }
-    // Returns a copy of the current node, optionally replacing pieces of it.
-    copy(key, value, color, left, right) {
-        return new LLRBNode(key != null ? key : this.key, value != null ? value : this.value, color != null ? color : this.color, left != null ? left : this.left, right != null ? right : this.right);
+    else if (source.mapValue) {
+        const target = { mapValue: { fields: {} } };
+        forEach(source.mapValue.fields, (key, val) => (target.mapValue.fields[key] = deepClone(val)));
+        return target;
     }
-    isEmpty() {
-        return false;
+    else if (source.arrayValue) {
+        const target = { arrayValue: { values: [] } };
+        for (let i = 0; i < (source.arrayValue.values || []).length; ++i) {
+            target.arrayValue.values[i] = deepClone(source.arrayValue.values[i]);
+        }
+        return target;
     }
-    // Traverses the tree in key order and calls the specified action function
-    // for each node. If action returns true, traversal is aborted.
-    // Returns the first truthy value returned by action, or the last falsey
-    // value returned by action.
-    inorderTraversal(action) {
-        return (this.left.inorderTraversal(action) ||
-            action(this.key, this.value) ||
-            this.right.inorderTraversal(action));
+    else {
+        return Object.assign({}, source);
     }
-    // Traverses the tree in reverse key order and calls the specified action
-    // function for each node. If action returns true, traversal is aborted.
-    // Returns the first truthy value returned by action, or the last falsey
-    // value returned by action.
-    reverseTraversal(action) {
-        return (this.right.reverseTraversal(action) ||
-            action(this.key, this.value) ||
-            this.left.reverseTraversal(action));
+}
+/** Returns true if the Value represents the canonical {@link #MAX_VALUE} . */
+function isMaxValue(value) {
+    return ((((value.mapValue || {}).fields || {})['__type__'] || {}).stringValue ===
+        MAX_VALUE_TYPE);
+}
+
+/**
+ * @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.
+ */
+/**
+ * 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;
     }
-    // Returns the minimum node in the tree.
-    min() {
-        if (this.left.isEmpty()) {
-            return this;
-        }
-        else {
-            return this.left.min();
-        }
+}
+function boundEquals(left, right) {
+    if (left === null) {
+        return right === null;
     }
-    // Returns the maximum key in the tree.
-    minKey() {
-        return this.min().key;
+    else if (right === null) {
+        return false;
     }
-    // Returns the maximum key in the tree.
-    maxKey() {
-        if (this.right.isEmpty()) {
-            return this.key;
-        }
-        else {
-            return this.right.maxKey();
-        }
+    if (left.inclusive !== right.inclusive ||
+        left.position.length !== right.position.length) {
+        return false;
     }
-    // Returns new tree, with the key/value added.
-    insert(key, value, comparator) {
-        let n = this;
-        const cmp = comparator(key, n.key);
-        if (cmp < 0) {
-            n = n.copy(null, null, null, n.left.insert(key, value, comparator), null);
-        }
-        else if (cmp === 0) {
-            n = n.copy(null, value, null, null, null);
-        }
-        else {
-            n = n.copy(null, null, null, null, n.right.insert(key, value, comparator));
+    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 n.fixUp();
     }
-    removeMin() {
-        if (this.left.isEmpty()) {
-            return LLRBNode.EMPTY;
-        }
-        let n = this;
-        if (!n.left.isRed() && !n.left.left.isRed()) {
-            n = n.moveRedLeft();
-        }
-        n = n.copy(null, null, null, n.left.removeMin(), null);
-        return n.fixUp();
+    return true;
+}
+
+/**
+ * @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.
+ */
+class Filter {
+}
+class FieldFilter extends Filter {
+    constructor(field, op, value) {
+        super();
+        this.field = field;
+        this.op = op;
+        this.value = value;
     }
-    // Returns new tree, with the specified item removed.
-    remove(key, comparator) {
-        let smallest;
-        let n = this;
-        if (comparator(key, n.key) < 0) {
-            if (!n.left.isEmpty() && !n.left.isRed() && !n.left.left.isRed()) {
-                n = n.moveRedLeft();
-            }
-            n = n.copy(null, null, null, n.left.remove(key, comparator), null);
-        }
-        else {
-            if (n.left.isRed()) {
-                n = n.rotateRight();
-            }
-            if (!n.right.isEmpty() && !n.right.isRed() && !n.right.left.isRed()) {
-                n = n.moveRedRight();
+    /**
+     * 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);
             }
-            if (comparator(key, n.key) === 0) {
-                if (n.right.isEmpty()) {
-                    return LLRBNode.EMPTY;
-                }
-                else {
-                    smallest = n.right.min();
-                    n = n.copy(smallest.key, smallest.value, null, null, n.right.removeMin());
-                }
+            else {
+                return new KeyFieldFilter(field, op, value);
             }
-            n = n.copy(null, null, null, null, n.right.remove(key, comparator));
         }
-        return n.fixUp();
-    }
-    isRed() {
-        return this.color;
-    }
-    // Returns new tree after performing any needed rotations.
-    fixUp() {
-        let n = this;
-        if (n.right.isRed() && !n.left.isRed()) {
-            n = n.rotateLeft();
+        else if (op === "array-contains" /* Operator.ARRAY_CONTAINS */) {
+            return new ArrayContainsFilter(field, value);
         }
-        if (n.left.isRed() && n.left.left.isRed()) {
-            n = n.rotateRight();
+        else if (op === "in" /* Operator.IN */) {
+            return new InFilter(field, value);
         }
-        if (n.left.isRed() && n.right.isRed()) {
-            n = n.colorFlip();
+        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);
         }
-        return n;
     }
-    moveRedLeft() {
-        let n = this.colorFlip();
-        if (n.right.left.isRed()) {
-            n = n.copy(null, null, null, null, n.right.rotateRight());
-            n = n.rotateLeft();
-            n = n.colorFlip();
+    static createKeyFieldInFilter(field, op, value) {
+        return op === "in" /* Operator.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 === "!=" /* Operator.NOT_EQUAL */) {
+            return (other !== null &&
+                this.matchesComparison(valueCompare(other, this.value)));
         }
-        return n;
+        // 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)));
     }
-    moveRedRight() {
-        let n = this.colorFlip();
-        if (n.left.left.isRed()) {
-            n = n.rotateRight();
-            n = n.colorFlip();
+    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();
         }
-        return n;
     }
-    rotateLeft() {
-        const nl = this.copy(null, null, LLRBNode.RED, null, this.right.left);
-        return this.right.copy(null, null, this.color, nl, null);
+    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);
     }
-    rotateRight() {
-        const nr = this.copy(null, null, LLRBNode.RED, this.left.right, null);
-        return this.left.copy(null, null, this.color, null, nr);
+    getFlattenedFilters() {
+        return [this];
     }
-    colorFlip() {
-        const left = this.left.copy(null, null, !this.left.color, null, null);
-        const right = this.right.copy(null, null, !this.right.color, null, null);
-        return this.copy(null, null, !this.color, left, right);
+    getFilters() {
+        return [this];
     }
-    // For testing.
-    checkMaxDepth() {
-        const blackDepth = this.check();
-        if (Math.pow(2.0, blackDepth) <= this.size + 1) {
-            return true;
+    getFirstInequalityField() {
+        if (this.isInequality()) {
+            return this.field;
+        }
+        return null;
+    }
+}
+class CompositeFilter extends Filter {
+    constructor(filters, op) {
+        super();
+        this.filters = filters;
+        this.op = op;
+        this.memoizedFlattenedFilters = null;
+    }
+    /**
+     * Creates a filter based on the provided arguments.
+     */
+    static create(filters, op) {
+        return new CompositeFilter(filters, op);
+    }
+    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 {
-            return false;
+            // For disjunctions, at least one filter should match.
+            return this.filters.find(filter => filter.matches(doc)) !== undefined;
         }
     }
-    // In a balanced RB tree, the black-depth (number of black nodes) from root to
-    // leaves is equal on both sides.  This function verifies that or asserts.
-    check() {
-        if (this.isRed() && this.left.isRed()) {
-            throw fail();
-        }
-        if (this.right.isRed()) {
-            throw fail();
+    getFlattenedFilters() {
+        if (this.memoizedFlattenedFilters !== null) {
+            return this.memoizedFlattenedFilters;
         }
-        const blackDepth = this.left.check();
-        if (blackDepth !== this.right.check()) {
-            throw fail();
+        this.memoizedFlattenedFilters = this.filters.reduce((result, subfilter) => {
+            return result.concat(subfilter.getFlattenedFilters());
+        }, []);
+        return this.memoizedFlattenedFilters;
+    }
+    // Returns a mutable copy of `this.filters`
+    getFilters() {
+        return Object.assign([], this.filters);
+    }
+    getFirstInequalityField() {
+        const found = this.findFirstMatchingFilter(filter => filter.isInequality());
+        if (found !== null) {
+            return found.field;
         }
-        else {
-            return blackDepth + (this.isRed() ? 0 : 1);
+        return null;
+    }
+    // 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;
     }
-} // end LLRBNode
-// Empty node is shared between all LLRB trees.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-LLRBNode.EMPTY = null;
-LLRBNode.RED = true;
-LLRBNode.BLACK = false;
-// Represents an empty node (a leaf node in the Red-Black Tree).
-class LLRBEmptyNode {
-    constructor() {
-        this.size = 0;
+}
+function compositeFilterIsConjunction(compositeFilter) {
+    return compositeFilter.op === "and" /* CompositeOperator.AND */;
+}
+function filterEquals(f1, f2) {
+    if (f1 instanceof FieldFilter) {
+        return fieldFilterEquals(f1, f2);
     }
-    get key() {
-        throw fail();
+    else if (f1 instanceof CompositeFilter) {
+        return compositeFilterEquals(f1, f2);
     }
-    get value() {
-        throw fail();
+    else {
+        fail();
     }
-    get color() {
-        throw fail();
+}
+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;
     }
-    get left() {
-        throw fail();
+    return false;
+}
+/** Filter that matches on key fields (i.e. '__name__'). */
+class KeyFieldFilter extends FieldFilter {
+    constructor(field, op, value) {
+        super(field, op, value);
+        this.key = DocumentKey.fromName(value.referenceValue);
     }
-    get right() {
-        throw fail();
+    matches(doc) {
+        const comparison = DocumentKey.comparator(doc.key, this.key);
+        return this.matchesComparison(comparison);
     }
-    // Returns a copy of the current node.
-    copy(key, value, color, left, right) {
-        return this;
+}
+/** Filter that matches on key fields within an array. */
+class KeyFieldInFilter extends FieldFilter {
+    constructor(field, value) {
+        super(field, "in" /* Operator.IN */, value);
+        this.keys = extractDocumentKeysFromArrayValue("in" /* Operator.IN */, value);
     }
-    // Returns a copy of the tree, with the specified key/value added.
-    insert(key, value, comparator) {
-        return new LLRBNode(key, value);
+    matches(doc) {
+        return this.keys.some(key => key.isEqual(doc.key));
     }
-    // Returns a copy of the tree, with the specified key removed.
-    remove(key, comparator) {
-        return this;
+}
+/** Filter that matches on key fields not present within an array. */
+class KeyFieldNotInFilter extends FieldFilter {
+    constructor(field, 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));
+    }
+}
+function extractDocumentKeysFromArrayValue(op, value) {
+    var _a;
+    return (((_a = value.arrayValue) === null || _a === void 0 ? void 0 : _a.values) || []).map(v => {
+        return DocumentKey.fromName(v.referenceValue);
+    });
+}
+/** A Filter that implements the array-contains operator. */
+class ArrayContainsFilter extends FieldFilter {
+    constructor(field, value) {
+        super(field, "array-contains" /* Operator.ARRAY_CONTAINS */, value);
+    }
+    matches(doc) {
+        const other = doc.data.field(this.field);
+        return isArray(other) && arrayValueContains(other.arrayValue, this.value);
+    }
+}
+/** A Filter that implements the IN operator. */
+class InFilter extends FieldFilter {
+    constructor(field, value) {
+        super(field, "in" /* Operator.IN */, value);
+    }
+    matches(doc) {
+        const other = doc.data.field(this.field);
+        return other !== null && arrayValueContains(this.value.arrayValue, other);
+    }
+}
+/** A Filter that implements the not-in operator. */
+class NotInFilter extends FieldFilter {
+    constructor(field, value) {
+        super(field, "not-in" /* Operator.NOT_IN */, value);
+    }
+    matches(doc) {
+        if (arrayValueContains(this.value.arrayValue, { nullValue: 'NULL_VALUE' })) {
+            return false;
+        }
+        const other = doc.data.field(this.field);
+        return other !== null && !arrayValueContains(this.value.arrayValue, other);
+    }
+}
+/** A Filter that implements the array-contains-any operator. */
+class ArrayContainsAnyFilter extends FieldFilter {
+    constructor(field, value) {
+        super(field, "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */, value);
+    }
+    matches(doc) {
+        const other = doc.data.field(this.field);
+        if (!isArray(other) || !other.arrayValue.values) {
+            return false;
+        }
+        return other.arrayValue.values.some(val => arrayValueContains(this.value.arrayValue, val));
+    }
+}
+
+/**
+ * @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.
+ */
+/**
+ * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
+ */
+class OrderBy {
+    constructor(field, dir = "asc" /* Direction.ASCENDING */) {
+        this.field = field;
+        this.dir = dir;
+    }
+}
+function orderByEquals(left, right) {
+    return left.dir === right.dir && left.field.isEqual(right.field);
+}
+
+/**
+ * @license
+ * Copyright 2017 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.
+ */
+/**
+ * A version of a document in Firestore. This corresponds to the version
+ * timestamp, such as update_time or read_time.
+ */
+class SnapshotVersion {
+    constructor(timestamp) {
+        this.timestamp = timestamp;
     }
-    isEmpty() {
-        return true;
+    static fromTimestamp(value) {
+        return new SnapshotVersion(value);
     }
-    inorderTraversal(action) {
-        return false;
+    static min() {
+        return new SnapshotVersion(new Timestamp(0, 0));
     }
-    reverseTraversal(action) {
-        return false;
+    static max() {
+        return new SnapshotVersion(new Timestamp(253402300799, 1e9 - 1));
     }
-    minKey() {
-        return null;
+    compareTo(other) {
+        return this.timestamp._compareTo(other.timestamp);
     }
-    maxKey() {
-        return null;
+    isEqual(other) {
+        return this.timestamp.isEqual(other.timestamp);
     }
-    isRed() {
-        return false;
+    /** Returns a number representation of the version for use in spec tests. */
+    toMicroseconds() {
+        // Convert to microseconds.
+        return this.timestamp.seconds * 1e6 + this.timestamp.nanoseconds / 1000;
     }
-    // For testing.
-    checkMaxDepth() {
-        return true;
+    toString() {
+        return 'SnapshotVersion(' + this.timestamp.toString() + ')';
     }
-    check() {
-        return 0;
+    toTimestamp() {
+        return this.timestamp;
     }
-} // end LLRBEmptyNode
-LLRBNode.EMPTY = new LLRBEmptyNode();
+}
 
 /**
  * @license
@@ -2332,484 +2897,445 @@ LLRBNode.EMPTY = new LLRBEmptyNode();
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
- * SortedSet is an immutable (copy-on-write) collection that holds elements
- * in order specified by the provided comparator.
- *
- * NOTE: if provided comparator returns 0 for two elements, we consider them to
- * be equal!
- */
-class SortedSet {
-    constructor(comparator) {
+// An immutable sorted map implementation, based on a Left-leaning Red-Black
+// tree.
+class SortedMap {
+    constructor(comparator, root) {
         this.comparator = comparator;
-        this.data = new SortedMap(this.comparator);
+        this.root = root ? root : LLRBNode.EMPTY;
     }
-    has(elem) {
-        return this.data.get(elem) !== null;
+    // Returns a copy of the map, with the specified key/value added or replaced.
+    insert(key, value) {
+        return new SortedMap(this.comparator, this.root
+            .insert(key, value, this.comparator)
+            .copy(null, null, LLRBNode.BLACK, null, null));
     }
-    first() {
-        return this.data.minKey();
+    // Returns a copy of the map, with the specified key removed.
+    remove(key) {
+        return new SortedMap(this.comparator, this.root
+            .remove(key, this.comparator)
+            .copy(null, null, LLRBNode.BLACK, null, null));
     }
-    last() {
-        return this.data.maxKey();
+    // Returns the value of the node with the given key, or null.
+    get(key) {
+        let node = this.root;
+        while (!node.isEmpty()) {
+            const cmp = this.comparator(key, node.key);
+            if (cmp === 0) {
+                return node.value;
+            }
+            else if (cmp < 0) {
+                node = node.left;
+            }
+            else if (cmp > 0) {
+                node = node.right;
+            }
+        }
+        return null;
+    }
+    // Returns the index of the element in this sorted map, or -1 if it doesn't
+    // exist.
+    indexOf(key) {
+        // Number of nodes that were pruned when descending right
+        let prunedNodes = 0;
+        let node = this.root;
+        while (!node.isEmpty()) {
+            const cmp = this.comparator(key, node.key);
+            if (cmp === 0) {
+                return prunedNodes + node.left.size;
+            }
+            else if (cmp < 0) {
+                node = node.left;
+            }
+            else {
+                // Count all nodes left of the node plus the node itself
+                prunedNodes += node.left.size + 1;
+                node = node.right;
+            }
+        }
+        // Node not found
+        return -1;
+    }
+    isEmpty() {
+        return this.root.isEmpty();
     }
+    // Returns the total number of nodes in the map.
     get size() {
-        return this.data.size;
+        return this.root.size;
     }
-    indexOf(elem) {
-        return this.data.indexOf(elem);
+    // Returns the minimum key in the map.
+    minKey() {
+        return this.root.minKey();
     }
-    /** Iterates elements in order defined by "comparator" */
-    forEach(cb) {
-        this.data.inorderTraversal((k, v) => {
-            cb(k);
+    // Returns the maximum key in the map.
+    maxKey() {
+        return this.root.maxKey();
+    }
+    // Traverses the map in key order and calls the specified action function
+    // for each key/value pair. If action returns true, traversal is aborted.
+    // Returns the first truthy value returned by action, or the last falsey
+    // value returned by action.
+    inorderTraversal(action) {
+        return this.root.inorderTraversal(action);
+    }
+    forEach(fn) {
+        this.inorderTraversal((k, v) => {
+            fn(k, v);
             return false;
         });
     }
-    /** Iterates over `elem`s such that: range[0] &lt;= elem &lt; range[1]. */
-    forEachInRange(range, cb) {
-        const iter = this.data.getIteratorFrom(range[0]);
-        while (iter.hasNext()) {
-            const elem = iter.getNext();
-            if (this.comparator(elem.key, range[1]) >= 0) {
-                return;
-            }
-            cb(elem.key);
-        }
-    }
-    /**
-     * Iterates over `elem`s such that: start &lt;= elem until false is returned.
-     */
-    forEachWhile(cb, start) {
-        let iter;
-        if (start !== undefined) {
-            iter = this.data.getIteratorFrom(start);
-        }
-        else {
-            iter = this.data.getIterator();
-        }
-        while (iter.hasNext()) {
-            const elem = iter.getNext();
-            const result = cb(elem.key);
-            if (!result) {
-                return;
-            }
-        }
+    toString() {
+        const descriptions = [];
+        this.inorderTraversal((k, v) => {
+            descriptions.push(`${k}:${v}`);
+            return false;
+        });
+        return `{${descriptions.join(', ')}}`;
     }
-    /** Finds the least element greater than or equal to `elem`. */
-    firstAfterOrEqual(elem) {
-        const iter = this.data.getIteratorFrom(elem);
-        return iter.hasNext() ? iter.getNext().key : null;
+    // Traverses the map in reverse key order and calls the specified action
+    // function for each key/value pair. If action returns true, traversal is
+    // aborted.
+    // Returns the first truthy value returned by action, or the last falsey
+    // value returned by action.
+    reverseTraversal(action) {
+        return this.root.reverseTraversal(action);
     }
+    // Returns an iterator over the SortedMap.
     getIterator() {
-        return new SortedSetIterator(this.data.getIterator());
+        return new SortedMapIterator(this.root, null, this.comparator, false);
     }
     getIteratorFrom(key) {
-        return new SortedSetIterator(this.data.getIteratorFrom(key));
-    }
-    /** Inserts or updates an element */
-    add(elem) {
-        return this.copy(this.data.remove(elem).insert(elem, true));
+        return new SortedMapIterator(this.root, key, this.comparator, false);
     }
-    /** Deletes an element */
-    delete(elem) {
-        if (!this.has(elem)) {
-            return this;
-        }
-        return this.copy(this.data.remove(elem));
+    getReverseIterator() {
+        return new SortedMapIterator(this.root, null, this.comparator, true);
     }
-    isEmpty() {
-        return this.data.isEmpty();
+    getReverseIteratorFrom(key) {
+        return new SortedMapIterator(this.root, key, this.comparator, true);
     }
-    unionWith(other) {
-        let result = this;
-        // Make sure `result` always refers to the larger one of the two sets.
-        if (result.size < other.size) {
-            result = other;
-            other = this;
+} // end SortedMap
+// An iterator over an LLRBNode.
+class SortedMapIterator {
+    constructor(node, startKey, comparator, isReverse) {
+        this.isReverse = isReverse;
+        this.nodeStack = [];
+        let cmp = 1;
+        while (!node.isEmpty()) {
+            cmp = startKey ? comparator(node.key, startKey) : 1;
+            // flip the comparison if we're going in reverse
+            if (startKey && isReverse) {
+                cmp *= -1;
+            }
+            if (cmp < 0) {
+                // This node is less than our start key. ignore it
+                if (this.isReverse) {
+                    node = node.left;
+                }
+                else {
+                    node = node.right;
+                }
+            }
+            else if (cmp === 0) {
+                // This node is exactly equal to our start key. Push it on the stack,
+                // but stop iterating;
+                this.nodeStack.push(node);
+                break;
+            }
+            else {
+                // This node is greater than our start key, add it to the stack and move
+                // to the next one
+                this.nodeStack.push(node);
+                if (this.isReverse) {
+                    node = node.right;
+                }
+                else {
+                    node = node.left;
+                }
+            }
         }
-        other.forEach(elem => {
-            result = result.add(elem);
-        });
-        return result;
     }
-    isEqual(other) {
-        if (!(other instanceof SortedSet)) {
-            return false;
-        }
-        if (this.size !== other.size) {
-            return false;
+    getNext() {
+        let node = this.nodeStack.pop();
+        const result = { key: node.key, value: node.value };
+        if (this.isReverse) {
+            node = node.left;
+            while (!node.isEmpty()) {
+                this.nodeStack.push(node);
+                node = node.right;
+            }
         }
-        const thisIt = this.data.getIterator();
-        const otherIt = other.data.getIterator();
-        while (thisIt.hasNext()) {
-            const thisElem = thisIt.getNext().key;
-            const otherElem = otherIt.getNext().key;
-            if (this.comparator(thisElem, otherElem) !== 0) {
-                return false;
+        else {
+            node = node.right;
+            while (!node.isEmpty()) {
+                this.nodeStack.push(node);
+                node = node.left;
             }
         }
-        return true;
-    }
-    toArray() {
-        const res = [];
-        this.forEach(targetId => {
-            res.push(targetId);
-        });
-        return res;
+        return result;
     }
-    toString() {
-        const result = [];
-        this.forEach(elem => result.push(elem));
-        return 'SortedSet(' + result.toString() + ')';
+    hasNext() {
+        return this.nodeStack.length > 0;
     }
-    copy(data) {
-        const result = new SortedSet(this.comparator);
-        result.data = data;
-        return result;
+    peek() {
+        if (this.nodeStack.length === 0) {
+            return null;
+        }
+        const node = this.nodeStack[this.nodeStack.length - 1];
+        return { key: node.key, value: node.value };
     }
-}
-class SortedSetIterator {
-    constructor(iter) {
-        this.iter = iter;
+} // end SortedMapIterator
+// Represents a node in a Left-leaning Red-Black tree.
+class LLRBNode {
+    constructor(key, value, color, left, right) {
+        this.key = key;
+        this.value = value;
+        this.color = color != null ? color : LLRBNode.RED;
+        this.left = left != null ? left : LLRBNode.EMPTY;
+        this.right = right != null ? right : LLRBNode.EMPTY;
+        this.size = this.left.size + 1 + this.right.size;
     }
-    getNext() {
-        return this.iter.getNext().key;
+    // Returns a copy of the current node, optionally replacing pieces of it.
+    copy(key, value, color, left, right) {
+        return new LLRBNode(key != null ? key : this.key, value != null ? value : this.value, color != null ? color : this.color, left != null ? left : this.left, right != null ? right : this.right);
     }
-    hasNext() {
-        return this.iter.hasNext();
+    isEmpty() {
+        return false;
     }
-}
-
-/**
- * @license
- * Copyright 2020 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 a set of fields that can be used to partially patch a document.
- * FieldMask is used in conjunction with ObjectValue.
- * Examples:
- *   foo - Overwrites foo entirely with the provided value. If foo is not
- *         present in the companion ObjectValue, the field is deleted.
- *   foo.bar - Overwrites only the field bar of the object foo.
- *             If foo is not an object, foo is replaced with an object
- *             containing foo
- */
-class FieldMask {
-    constructor(fields) {
-        this.fields = fields;
-        // TODO(dimond): validation of FieldMask
-        // Sort the field mask to support `FieldMask.isEqual()` and assert below.
-        fields.sort(FieldPath$1.comparator);
+    // Traverses the tree in key order and calls the specified action function
+    // for each node. If action returns true, traversal is aborted.
+    // Returns the first truthy value returned by action, or the last falsey
+    // value returned by action.
+    inorderTraversal(action) {
+        return (this.left.inorderTraversal(action) ||
+            action(this.key, this.value) ||
+            this.right.inorderTraversal(action));
     }
-    static empty() {
-        return new FieldMask([]);
+    // Traverses the tree in reverse key order and calls the specified action
+    // function for each node. If action returns true, traversal is aborted.
+    // Returns the first truthy value returned by action, or the last falsey
+    // value returned by action.
+    reverseTraversal(action) {
+        return (this.right.reverseTraversal(action) ||
+            action(this.key, this.value) ||
+            this.left.reverseTraversal(action));
     }
-    /**
-     * Returns a new FieldMask object that is the result of adding all the given
-     * fields paths to this field mask.
-     */
-    unionWith(extraFields) {
-        let mergedMaskSet = new SortedSet(FieldPath$1.comparator);
-        for (const fieldPath of this.fields) {
-            mergedMaskSet = mergedMaskSet.add(fieldPath);
-        }
-        for (const fieldPath of extraFields) {
-            mergedMaskSet = mergedMaskSet.add(fieldPath);
+    // Returns the minimum node in the tree.
+    min() {
+        if (this.left.isEmpty()) {
+            return this;
         }
-        return new FieldMask(mergedMaskSet.toArray());
-    }
-    /**
-     * Verifies that `fieldPath` is included by at least one field in this field
-     * mask.
-     *
-     * This is an O(n) operation, where `n` is the size of the field mask.
-     */
-    covers(fieldPath) {
-        for (const fieldMaskPath of this.fields) {
-            if (fieldMaskPath.isPrefixOf(fieldPath)) {
-                return true;
-            }
+        else {
+            return this.left.min();
         }
-        return false;
     }
-    isEqual(other) {
-        return arrayEquals(this.fields, other.fields, (l, r) => l.isEqual(r));
+    // Returns the maximum key in the tree.
+    minKey() {
+        return this.min().key;
     }
-}
-
-/**
- * @license
- * Copyright 2020 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.
- */
-/** Converts a Base64 encoded string to a binary string. */
-function decodeBase64(encoded) {
-    // Note: We used to validate the base64 string here via a regular expression.
-    // This was removed to improve the performance of indexing.
-    return Buffer.from(encoded, 'base64').toString('binary');
-}
-/** Converts a binary string to a Base64 encoded string. */
-function encodeBase64(raw) {
-    return Buffer.from(raw, 'binary').toString('base64');
-}
-
-/**
- * @license
- * Copyright 2020 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.
- */
-/**
- * Immutable class that represents a "proto" byte string.
- *
- * Proto byte strings can either be Base64-encoded strings or Uint8Arrays when
- * sent on the wire. This class abstracts away this differentiation by holding
- * the proto byte string in a common class that must be converted into a string
- * before being sent as a proto.
- * @internal
- */
-class ByteString {
-    constructor(binaryString) {
-        this.binaryString = binaryString;
+    // Returns the maximum key in the tree.
+    maxKey() {
+        if (this.right.isEmpty()) {
+            return this.key;
+        }
+        else {
+            return this.right.maxKey();
+        }
     }
-    static fromBase64String(base64) {
-        const binaryString = decodeBase64(base64);
-        return new ByteString(binaryString);
+    // Returns new tree, with the key/value added.
+    insert(key, value, comparator) {
+        let n = this;
+        const cmp = comparator(key, n.key);
+        if (cmp < 0) {
+            n = n.copy(null, null, null, n.left.insert(key, value, comparator), null);
+        }
+        else if (cmp === 0) {
+            n = n.copy(null, value, null, null, null);
+        }
+        else {
+            n = n.copy(null, null, null, null, n.right.insert(key, value, comparator));
+        }
+        return n.fixUp();
     }
-    static fromUint8Array(array) {
-        // TODO(indexing); Remove the copy of the byte string here as this method
-        // is frequently called during indexing.
-        const binaryString = binaryStringFromUint8Array(array);
-        return new ByteString(binaryString);
+    removeMin() {
+        if (this.left.isEmpty()) {
+            return LLRBNode.EMPTY;
+        }
+        let n = this;
+        if (!n.left.isRed() && !n.left.left.isRed()) {
+            n = n.moveRedLeft();
+        }
+        n = n.copy(null, null, null, n.left.removeMin(), null);
+        return n.fixUp();
     }
-    [Symbol.iterator]() {
-        let i = 0;
-        return {
-            next: () => {
-                if (i < this.binaryString.length) {
-                    return { value: this.binaryString.charCodeAt(i++), done: false };
+    // Returns new tree, with the specified item removed.
+    remove(key, comparator) {
+        let smallest;
+        let n = this;
+        if (comparator(key, n.key) < 0) {
+            if (!n.left.isEmpty() && !n.left.isRed() && !n.left.left.isRed()) {
+                n = n.moveRedLeft();
+            }
+            n = n.copy(null, null, null, n.left.remove(key, comparator), null);
+        }
+        else {
+            if (n.left.isRed()) {
+                n = n.rotateRight();
+            }
+            if (!n.right.isEmpty() && !n.right.isRed() && !n.right.left.isRed()) {
+                n = n.moveRedRight();
+            }
+            if (comparator(key, n.key) === 0) {
+                if (n.right.isEmpty()) {
+                    return LLRBNode.EMPTY;
                 }
                 else {
-                    return { value: undefined, done: true };
+                    smallest = n.right.min();
+                    n = n.copy(smallest.key, smallest.value, null, null, n.right.removeMin());
                 }
             }
-        };
+            n = n.copy(null, null, null, null, n.right.remove(key, comparator));
+        }
+        return n.fixUp();
     }
-    toBase64() {
-        return encodeBase64(this.binaryString);
+    isRed() {
+        return this.color;
     }
-    toUint8Array() {
-        return uint8ArrayFromBinaryString(this.binaryString);
+    // Returns new tree after performing any needed rotations.
+    fixUp() {
+        let n = this;
+        if (n.right.isRed() && !n.left.isRed()) {
+            n = n.rotateLeft();
+        }
+        if (n.left.isRed() && n.left.left.isRed()) {
+            n = n.rotateRight();
+        }
+        if (n.left.isRed() && n.right.isRed()) {
+            n = n.colorFlip();
+        }
+        return n;
     }
-    approximateByteSize() {
-        return this.binaryString.length * 2;
+    moveRedLeft() {
+        let n = this.colorFlip();
+        if (n.right.left.isRed()) {
+            n = n.copy(null, null, null, null, n.right.rotateRight());
+            n = n.rotateLeft();
+            n = n.colorFlip();
+        }
+        return n;
     }
-    compareTo(other) {
-        return primitiveComparator(this.binaryString, other.binaryString);
+    moveRedRight() {
+        let n = this.colorFlip();
+        if (n.left.left.isRed()) {
+            n = n.rotateRight();
+            n = n.colorFlip();
+        }
+        return n;
     }
-    isEqual(other) {
-        return this.binaryString === other.binaryString;
+    rotateLeft() {
+        const nl = this.copy(null, null, LLRBNode.RED, null, this.right.left);
+        return this.right.copy(null, null, this.color, nl, null);
     }
-}
-ByteString.EMPTY_BYTE_STRING = new ByteString('');
-/**
- * Helper function to convert an Uint8array to a binary string.
- */
-function binaryStringFromUint8Array(array) {
-    let binaryString = '';
-    for (let i = 0; i < array.length; ++i) {
-        binaryString += String.fromCharCode(array[i]);
+    rotateRight() {
+        const nr = this.copy(null, null, LLRBNode.RED, this.left.right, null);
+        return this.left.copy(null, null, this.color, null, nr);
     }
-    return binaryString;
-}
-/**
- * Helper function to convert a binary string to an Uint8Array.
- */
-function uint8ArrayFromBinaryString(binaryString) {
-    const buffer = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-        buffer[i] = binaryString.charCodeAt(i);
+    colorFlip() {
+        const left = this.left.copy(null, null, !this.left.color, null, null);
+        const right = this.right.copy(null, null, !this.right.color, null, null);
+        return this.copy(null, null, !this.color, left, right);
     }
-    return buffer;
-}
-
-/**
- * @license
- * Copyright 2020 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.
- */
-// A RegExp matching ISO 8601 UTC timestamps with optional fraction.
-const ISO_TIMESTAMP_REG_EXP = new RegExp(/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.(\d+))?Z$/);
-/**
- * Converts the possible Proto values for a timestamp value into a "seconds and
- * nanos" representation.
- */
-function normalizeTimestamp(date) {
-    hardAssert(!!date);
-    // The json interface (for the browser) will return an iso timestamp string,
-    // while the proto js library (for node) will return a
-    // google.protobuf.Timestamp instance.
-    if (typeof date === 'string') {
-        // The date string can have higher precision (nanos) than the Date class
-        // (millis), so we do some custom parsing here.
-        // Parse the nanos right out of the string.
-        let nanos = 0;
-        const fraction = ISO_TIMESTAMP_REG_EXP.exec(date);
-        hardAssert(!!fraction);
-        if (fraction[1]) {
-            // Pad the fraction out to 9 digits (nanos).
-            let nanoStr = fraction[1];
-            nanoStr = (nanoStr + '000000000').substr(0, 9);
-            nanos = Number(nanoStr);
+    // For testing.
+    checkMaxDepth() {
+        const blackDepth = this.check();
+        if (Math.pow(2.0, blackDepth) <= this.size + 1) {
+            return true;
+        }
+        else {
+            return false;
         }
-        // Parse the date to get the seconds.
-        const parsedDate = new Date(date);
-        const seconds = Math.floor(parsedDate.getTime() / 1000);
-        return { seconds, nanos };
     }
-    else {
-        // TODO(b/37282237): Use strings for Proto3 timestamps
-        // assert(!this.options.useProto3Json,
-        //   'The timestamp instance format requires Proto JS.');
-        const seconds = normalizeNumber(date.seconds);
-        const nanos = normalizeNumber(date.nanos);
-        return { seconds, nanos };
+    // In a balanced RB tree, the black-depth (number of black nodes) from root to
+    // leaves is equal on both sides.  This function verifies that or asserts.
+    check() {
+        if (this.isRed() && this.left.isRed()) {
+            throw fail();
+        }
+        if (this.right.isRed()) {
+            throw fail();
+        }
+        const blackDepth = this.left.check();
+        if (blackDepth !== this.right.check()) {
+            throw fail();
+        }
+        else {
+            return blackDepth + (this.isRed() ? 0 : 1);
+        }
     }
-}
-/**
- * Converts the possible Proto types for numbers into a JavaScript number.
- * Returns 0 if the value is not numeric.
- */
-function normalizeNumber(value) {
-    // TODO(bjornick): Handle int64 greater than 53 bits.
-    if (typeof value === 'number') {
-        return value;
+} // end LLRBNode
+// Empty node is shared between all LLRB trees.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+LLRBNode.EMPTY = null;
+LLRBNode.RED = true;
+LLRBNode.BLACK = false;
+// Represents an empty node (a leaf node in the Red-Black Tree).
+class LLRBEmptyNode {
+    constructor() {
+        this.size = 0;
     }
-    else if (typeof value === 'string') {
-        return Number(value);
+    get key() {
+        throw fail();
+    }
+    get value() {
+        throw fail();
+    }
+    get color() {
+        throw fail();
+    }
+    get left() {
+        throw fail();
+    }
+    get right() {
+        throw fail();
+    }
+    // Returns a copy of the current node.
+    copy(key, value, color, left, right) {
+        return this;
+    }
+    // Returns a copy of the tree, with the specified key/value added.
+    insert(key, value, comparator) {
+        return new LLRBNode(key, value);
+    }
+    // Returns a copy of the tree, with the specified key removed.
+    remove(key, comparator) {
+        return this;
+    }
+    isEmpty() {
+        return true;
+    }
+    inorderTraversal(action) {
+        return false;
+    }
+    reverseTraversal(action) {
+        return false;
+    }
+    minKey() {
+        return null;
     }
-    else {
-        return 0;
+    maxKey() {
+        return null;
     }
-}
-/** Converts the possible Proto types for Blobs into a ByteString. */
-function normalizeByteString(blob) {
-    if (typeof blob === 'string') {
-        return ByteString.fromBase64String(blob);
+    isRed() {
+        return false;
     }
-    else {
-        return ByteString.fromUint8Array(blob);
+    // For testing.
+    checkMaxDepth() {
+        return true;
     }
-}
-
-/**
- * @license
- * Copyright 2020 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.
- */
-/**
- * Represents a locally-applied ServerTimestamp.
- *
- * Server Timestamps are backed by MapValues that contain an internal field
- * `__type__` with a value of `server_timestamp`. The previous value and local
- * write time are stored in its `__previous_value__` and `__local_write_time__`
- * fields respectively.
- *
- * Notes:
- * - ServerTimestampValue instances are created as the result of applying a
- *   transform. They can only exist in the local view of a document. Therefore
- *   they do not need to be parsed or serialized.
- * - When evaluated locally (e.g. for snapshot.data()), they by default
- *   evaluate to `null`. This behavior can be configured by passing custom
- *   FieldValueOptions to value().
- * - With respect to other ServerTimestampValues, they sort by their
- *   localWriteTime.
- */
-const SERVER_TIMESTAMP_SENTINEL = 'server_timestamp';
-const TYPE_KEY = '__type__';
-const PREVIOUS_VALUE_KEY = '__previous_value__';
-const LOCAL_WRITE_TIME_KEY = '__local_write_time__';
-function isServerTimestamp(value) {
-    var _a, _b;
-    const type = (_b = (((_a = value === null || value === void 0 ? void 0 : value.mapValue) === null || _a === void 0 ? void 0 : _a.fields) || {})[TYPE_KEY]) === null || _b === void 0 ? void 0 : _b.stringValue;
-    return type === SERVER_TIMESTAMP_SENTINEL;
-}
-/**
- * Returns the value of the field before this ServerTimestamp was set.
- *
- * Preserving the previous values allows the user to display the last resoled
- * value until the backend responds with the timestamp.
- */
-function getPreviousValue(value) {
-    const previousValue = value.mapValue.fields[PREVIOUS_VALUE_KEY];
-    if (isServerTimestamp(previousValue)) {
-        return getPreviousValue(previousValue);
+    check() {
+        return 0;
     }
-    return previousValue;
-}
-/**
- * Returns the local time at which this timestamp was first set.
- */
-function getLocalWriteTime(value) {
-    const localWriteTime = normalizeTimestamp(value.mapValue.fields[LOCAL_WRITE_TIME_KEY].timestampValue);
-    return new Timestamp(localWriteTime.seconds, localWriteTime.nanos);
-}
+} // end LLRBEmptyNode
+LLRBNode.EMPTY = new LLRBEmptyNode();
 
 /**
  * @license
@@ -2828,381 +3354,221 @@ function getLocalWriteTime(value) {
  * limitations under the License.
  */
 /**
- * Returns whether a variable is either undefined or null.
- */
-function isNullOrUndefined(value) {
-    return value === null || value === undefined;
-}
-/** Returns whether the value represents -0. */
-function isNegativeZero(value) {
-    // Detect if the value is -0.0. Based on polyfill from
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
-    return value === 0 && 1 / value === 1 / -0;
-}
-/**
- * Returns whether a value is an integer and in the safe integer range
- * @param value - The value to test for being an integer and in the safe range
- */
-function isSafeInteger(value) {
-    return (typeof value === 'number' &&
-        Number.isInteger(value) &&
-        !isNegativeZero(value) &&
-        value <= Number.MAX_SAFE_INTEGER &&
-        value >= Number.MIN_SAFE_INTEGER);
-}
-
-/**
- * @license
- * Copyright 2020 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
+ * SortedSet is an immutable (copy-on-write) collection that holds elements
+ * in order specified by the provided comparator.
  *
- * 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.
+ * NOTE: if provided comparator returns 0 for two elements, we consider them to
+ * be equal!
  */
-const MAX_VALUE_TYPE = '__max__';
-const MAX_VALUE = {
-    mapValue: {
-        fields: {
-            '__type__': { stringValue: MAX_VALUE_TYPE }
-        }
-    }
-};
-/** Extracts the backend's type order for the provided value. */
-function typeOrder(value) {
-    if ('nullValue' in value) {
-        return 0 /* NullValue */;
-    }
-    else if ('booleanValue' in value) {
-        return 1 /* BooleanValue */;
-    }
-    else if ('integerValue' in value || 'doubleValue' in value) {
-        return 2 /* NumberValue */;
-    }
-    else if ('timestampValue' in value) {
-        return 3 /* TimestampValue */;
-    }
-    else if ('stringValue' in value) {
-        return 5 /* StringValue */;
-    }
-    else if ('bytesValue' in value) {
-        return 6 /* BlobValue */;
-    }
-    else if ('referenceValue' in value) {
-        return 7 /* RefValue */;
-    }
-    else if ('geoPointValue' in value) {
-        return 8 /* GeoPointValue */;
-    }
-    else if ('arrayValue' in value) {
-        return 9 /* ArrayValue */;
-    }
-    else if ('mapValue' in value) {
-        if (isServerTimestamp(value)) {
-            return 4 /* ServerTimestampValue */;
-        }
-        else if (isMaxValue(value)) {
-            return 9007199254740991 /* MaxValue */;
-        }
-        return 10 /* ObjectValue */;
-    }
-    else {
-        return fail();
-    }
-}
-/** Tests `left` and `right` for equality based on the backend semantics. */
-function valueEquals(left, right) {
-    if (left === right) {
-        return true;
-    }
-    const leftType = typeOrder(left);
-    const rightType = typeOrder(right);
-    if (leftType !== rightType) {
-        return false;
-    }
-    switch (leftType) {
-        case 0 /* NullValue */:
-            return true;
-        case 1 /* BooleanValue */:
-            return left.booleanValue === right.booleanValue;
-        case 4 /* ServerTimestampValue */:
-            return getLocalWriteTime(left).isEqual(getLocalWriteTime(right));
-        case 3 /* TimestampValue */:
-            return timestampEquals(left, right);
-        case 5 /* StringValue */:
-            return left.stringValue === right.stringValue;
-        case 6 /* BlobValue */:
-            return blobEquals(left, right);
-        case 7 /* RefValue */:
-            return left.referenceValue === right.referenceValue;
-        case 8 /* GeoPointValue */:
-            return geoPointEquals(left, right);
-        case 2 /* NumberValue */:
-            return numberEquals(left, right);
-        case 9 /* ArrayValue */:
-            return arrayEquals(left.arrayValue.values || [], right.arrayValue.values || [], valueEquals);
-        case 10 /* ObjectValue */:
-            return objectEquals(left, right);
-        case 9007199254740991 /* MaxValue */:
-            return true;
-        default:
-            return fail();
-    }
-}
-function timestampEquals(left, right) {
-    if (typeof left.timestampValue === 'string' &&
-        typeof right.timestampValue === 'string' &&
-        left.timestampValue.length === right.timestampValue.length) {
-        // Use string equality for ISO 8601 timestamps
-        return left.timestampValue === right.timestampValue;
-    }
-    const leftTimestamp = normalizeTimestamp(left.timestampValue);
-    const rightTimestamp = normalizeTimestamp(right.timestampValue);
-    return (leftTimestamp.seconds === rightTimestamp.seconds &&
-        leftTimestamp.nanos === rightTimestamp.nanos);
-}
-function geoPointEquals(left, right) {
-    return (normalizeNumber(left.geoPointValue.latitude) ===
-        normalizeNumber(right.geoPointValue.latitude) &&
-        normalizeNumber(left.geoPointValue.longitude) ===
-            normalizeNumber(right.geoPointValue.longitude));
-}
-function blobEquals(left, right) {
-    return normalizeByteString(left.bytesValue).isEqual(normalizeByteString(right.bytesValue));
-}
-function numberEquals(left, right) {
-    if ('integerValue' in left && 'integerValue' in right) {
-        return (normalizeNumber(left.integerValue) === normalizeNumber(right.integerValue));
-    }
-    else if ('doubleValue' in left && 'doubleValue' in right) {
-        const n1 = normalizeNumber(left.doubleValue);
-        const n2 = normalizeNumber(right.doubleValue);
-        if (n1 === n2) {
-            return isNegativeZero(n1) === isNegativeZero(n2);
-        }
-        else {
-            return isNaN(n1) && isNaN(n2);
-        }
-    }
-    return false;
-}
-function objectEquals(left, right) {
-    const leftMap = left.mapValue.fields || {};
-    const rightMap = right.mapValue.fields || {};
-    if (objectSize(leftMap) !== objectSize(rightMap)) {
-        return false;
+class SortedSet {
+    constructor(comparator) {
+        this.comparator = comparator;
+        this.data = new SortedMap(this.comparator);
     }
-    for (const key in leftMap) {
-        if (leftMap.hasOwnProperty(key)) {
-            if (rightMap[key] === undefined ||
-                !valueEquals(leftMap[key], rightMap[key])) {
-                return false;
-            }
-        }
+    has(elem) {
+        return this.data.get(elem) !== null;
     }
-    return true;
-}
-/** Returns true if the ArrayValue contains the specified element. */
-function arrayValueContains(haystack, needle) {
-    return ((haystack.values || []).find(v => valueEquals(v, needle)) !== undefined);
-}
-function valueCompare(left, right) {
-    if (left === right) {
-        return 0;
+    first() {
+        return this.data.minKey();
     }
-    const leftType = typeOrder(left);
-    const rightType = typeOrder(right);
-    if (leftType !== rightType) {
-        return primitiveComparator(leftType, rightType);
+    last() {
+        return this.data.maxKey();
     }
-    switch (leftType) {
-        case 0 /* NullValue */:
-        case 9007199254740991 /* MaxValue */:
-            return 0;
-        case 1 /* BooleanValue */:
-            return primitiveComparator(left.booleanValue, right.booleanValue);
-        case 2 /* NumberValue */:
-            return compareNumbers(left, right);
-        case 3 /* TimestampValue */:
-            return compareTimestamps(left.timestampValue, right.timestampValue);
-        case 4 /* ServerTimestampValue */:
-            return compareTimestamps(getLocalWriteTime(left), getLocalWriteTime(right));
-        case 5 /* StringValue */:
-            return primitiveComparator(left.stringValue, right.stringValue);
-        case 6 /* BlobValue */:
-            return compareBlobs(left.bytesValue, right.bytesValue);
-        case 7 /* RefValue */:
-            return compareReferences(left.referenceValue, right.referenceValue);
-        case 8 /* GeoPointValue */:
-            return compareGeoPoints(left.geoPointValue, right.geoPointValue);
-        case 9 /* ArrayValue */:
-            return compareArrays(left.arrayValue, right.arrayValue);
-        case 10 /* ObjectValue */:
-            return compareMaps(left.mapValue, right.mapValue);
-        default:
-            throw fail();
+    get size() {
+        return this.data.size;
     }
-}
-function compareNumbers(left, right) {
-    const leftNumber = normalizeNumber(left.integerValue || left.doubleValue);
-    const rightNumber = normalizeNumber(right.integerValue || right.doubleValue);
-    if (leftNumber < rightNumber) {
-        return -1;
+    indexOf(elem) {
+        return this.data.indexOf(elem);
     }
-    else if (leftNumber > rightNumber) {
-        return 1;
+    /** Iterates elements in order defined by "comparator" */
+    forEach(cb) {
+        this.data.inorderTraversal((k, v) => {
+            cb(k);
+            return false;
+        });
     }
-    else if (leftNumber === rightNumber) {
-        return 0;
+    /** Iterates over `elem`s such that: range[0] &lt;= elem &lt; range[1]. */
+    forEachInRange(range, cb) {
+        const iter = this.data.getIteratorFrom(range[0]);
+        while (iter.hasNext()) {
+            const elem = iter.getNext();
+            if (this.comparator(elem.key, range[1]) >= 0) {
+                return;
+            }
+            cb(elem.key);
+        }
     }
-    else {
-        // one or both are NaN.
-        if (isNaN(leftNumber)) {
-            return isNaN(rightNumber) ? 0 : -1;
+    /**
+     * Iterates over `elem`s such that: start &lt;= elem until false is returned.
+     */
+    forEachWhile(cb, start) {
+        let iter;
+        if (start !== undefined) {
+            iter = this.data.getIteratorFrom(start);
         }
         else {
-            return 1;
+            iter = this.data.getIterator();
+        }
+        while (iter.hasNext()) {
+            const elem = iter.getNext();
+            const result = cb(elem.key);
+            if (!result) {
+                return;
+            }
         }
     }
-}
-function compareTimestamps(left, right) {
-    if (typeof left === 'string' &&
-        typeof right === 'string' &&
-        left.length === right.length) {
-        return primitiveComparator(left, right);
+    /** Finds the least element greater than or equal to `elem`. */
+    firstAfterOrEqual(elem) {
+        const iter = this.data.getIteratorFrom(elem);
+        return iter.hasNext() ? iter.getNext().key : null;
     }
-    const leftTimestamp = normalizeTimestamp(left);
-    const rightTimestamp = normalizeTimestamp(right);
-    const comparison = primitiveComparator(leftTimestamp.seconds, rightTimestamp.seconds);
-    if (comparison !== 0) {
-        return comparison;
+    getIterator() {
+        return new SortedSetIterator(this.data.getIterator());
     }
-    return primitiveComparator(leftTimestamp.nanos, rightTimestamp.nanos);
-}
-function compareReferences(leftPath, rightPath) {
-    const leftSegments = leftPath.split('/');
-    const rightSegments = rightPath.split('/');
-    for (let i = 0; i < leftSegments.length && i < rightSegments.length; i++) {
-        const comparison = primitiveComparator(leftSegments[i], rightSegments[i]);
-        if (comparison !== 0) {
-            return comparison;
-        }
+    getIteratorFrom(key) {
+        return new SortedSetIterator(this.data.getIteratorFrom(key));
     }
-    return primitiveComparator(leftSegments.length, rightSegments.length);
-}
-function compareGeoPoints(left, right) {
-    const comparison = primitiveComparator(normalizeNumber(left.latitude), normalizeNumber(right.latitude));
-    if (comparison !== 0) {
-        return comparison;
+    /** Inserts or updates an element */
+    add(elem) {
+        return this.copy(this.data.remove(elem).insert(elem, true));
     }
-    return primitiveComparator(normalizeNumber(left.longitude), normalizeNumber(right.longitude));
-}
-function compareBlobs(left, right) {
-    const leftBytes = normalizeByteString(left);
-    const rightBytes = normalizeByteString(right);
-    return leftBytes.compareTo(rightBytes);
-}
-function compareArrays(left, right) {
-    const leftArray = left.values || [];
-    const rightArray = right.values || [];
-    for (let i = 0; i < leftArray.length && i < rightArray.length; ++i) {
-        const compare = valueCompare(leftArray[i], rightArray[i]);
-        if (compare) {
-            return compare;
+    /** Deletes an element */
+    delete(elem) {
+        if (!this.has(elem)) {
+            return this;
         }
+        return this.copy(this.data.remove(elem));
     }
-    return primitiveComparator(leftArray.length, rightArray.length);
-}
-function compareMaps(left, right) {
-    if (left === MAX_VALUE.mapValue && right === MAX_VALUE.mapValue) {
-        return 0;
-    }
-    else if (left === MAX_VALUE.mapValue) {
-        return 1;
+    isEmpty() {
+        return this.data.isEmpty();
     }
-    else if (right === MAX_VALUE.mapValue) {
-        return -1;
+    unionWith(other) {
+        let result = this;
+        // Make sure `result` always refers to the larger one of the two sets.
+        if (result.size < other.size) {
+            result = other;
+            other = this;
+        }
+        other.forEach(elem => {
+            result = result.add(elem);
+        });
+        return result;
     }
-    const leftMap = left.fields || {};
-    const leftKeys = Object.keys(leftMap);
-    const rightMap = right.fields || {};
-    const rightKeys = Object.keys(rightMap);
-    // Even though MapValues are likely sorted correctly based on their insertion
-    // order (e.g. when received from the backend), local modifications can bring
-    // elements out of order. We need to re-sort the elements to ensure that
-    // canonical IDs are independent of insertion order.
-    leftKeys.sort();
-    rightKeys.sort();
-    for (let i = 0; i < leftKeys.length && i < rightKeys.length; ++i) {
-        const keyCompare = primitiveComparator(leftKeys[i], rightKeys[i]);
-        if (keyCompare !== 0) {
-            return keyCompare;
+    isEqual(other) {
+        if (!(other instanceof SortedSet)) {
+            return false;
         }
-        const compare = valueCompare(leftMap[leftKeys[i]], rightMap[rightKeys[i]]);
-        if (compare !== 0) {
-            return compare;
+        if (this.size !== other.size) {
+            return false;
+        }
+        const thisIt = this.data.getIterator();
+        const otherIt = other.data.getIterator();
+        while (thisIt.hasNext()) {
+            const thisElem = thisIt.getNext().key;
+            const otherElem = otherIt.getNext().key;
+            if (this.comparator(thisElem, otherElem) !== 0) {
+                return false;
+            }
         }
+        return true;
+    }
+    toArray() {
+        const res = [];
+        this.forEach(targetId => {
+            res.push(targetId);
+        });
+        return res;
+    }
+    toString() {
+        const result = [];
+        this.forEach(elem => result.push(elem));
+        return 'SortedSet(' + result.toString() + ')';
+    }
+    copy(data) {
+        const result = new SortedSet(this.comparator);
+        result.data = data;
+        return result;
     }
-    return primitiveComparator(leftKeys.length, rightKeys.length);
-}
-/** Returns a reference value for the provided database and key. */
-function refValue(databaseId, key) {
-    return {
-        referenceValue: `projects/${databaseId.projectId}/databases/${databaseId.database}/documents/${key.path.canonicalString()}`
-    };
-}
-/** Returns true if `value` is an ArrayValue. */
-function isArray(value) {
-    return !!value && 'arrayValue' in value;
-}
-/** Returns true if `value` is a NullValue. */
-function isNullValue(value) {
-    return !!value && 'nullValue' in value;
-}
-/** Returns true if `value` is NaN. */
-function isNanValue(value) {
-    return !!value && 'doubleValue' in value && isNaN(Number(value.doubleValue));
-}
-/** Returns true if `value` is a MapValue. */
-function isMapValue(value) {
-    return !!value && 'mapValue' in value;
 }
-/** Creates a deep copy of `source`. */
-function deepClone(source) {
-    if (source.geoPointValue) {
-        return { geoPointValue: Object.assign({}, source.geoPointValue) };
+class SortedSetIterator {
+    constructor(iter) {
+        this.iter = iter;
+    }
+    getNext() {
+        return this.iter.getNext().key;
+    }
+    hasNext() {
+        return this.iter.hasNext();
+    }
+}
+
+/**
+ * @license
+ * Copyright 2020 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 a set of fields that can be used to partially patch a document.
+ * FieldMask is used in conjunction with ObjectValue.
+ * Examples:
+ *   foo - Overwrites foo entirely with the provided value. If foo is not
+ *         present in the companion ObjectValue, the field is deleted.
+ *   foo.bar - Overwrites only the field bar of the object foo.
+ *             If foo is not an object, foo is replaced with an object
+ *             containing foo
+ */
+class FieldMask {
+    constructor(fields) {
+        this.fields = fields;
+        // TODO(dimond): validation of FieldMask
+        // Sort the field mask to support `FieldMask.isEqual()` and assert below.
+        fields.sort(FieldPath$1.comparator);
     }
-    else if (source.timestampValue &&
-        typeof source.timestampValue === 'object') {
-        return { timestampValue: Object.assign({}, source.timestampValue) };
+    static empty() {
+        return new FieldMask([]);
     }
-    else if (source.mapValue) {
-        const target = { mapValue: { fields: {} } };
-        forEach(source.mapValue.fields, (key, val) => (target.mapValue.fields[key] = deepClone(val)));
-        return target;
+    /**
+     * Returns a new FieldMask object that is the result of adding all the given
+     * fields paths to this field mask.
+     */
+    unionWith(extraFields) {
+        let mergedMaskSet = new SortedSet(FieldPath$1.comparator);
+        for (const fieldPath of this.fields) {
+            mergedMaskSet = mergedMaskSet.add(fieldPath);
+        }
+        for (const fieldPath of extraFields) {
+            mergedMaskSet = mergedMaskSet.add(fieldPath);
+        }
+        return new FieldMask(mergedMaskSet.toArray());
     }
-    else if (source.arrayValue) {
-        const target = { arrayValue: { values: [] } };
-        for (let i = 0; i < (source.arrayValue.values || []).length; ++i) {
-            target.arrayValue.values[i] = deepClone(source.arrayValue.values[i]);
+    /**
+     * Verifies that `fieldPath` is included by at least one field in this field
+     * mask.
+     *
+     * This is an O(n) operation, where `n` is the size of the field mask.
+     */
+    covers(fieldPath) {
+        for (const fieldMaskPath of this.fields) {
+            if (fieldMaskPath.isPrefixOf(fieldPath)) {
+                return true;
+            }
         }
-        return target;
+        return false;
     }
-    else {
-        return Object.assign({}, source);
+    isEqual(other) {
+        return arrayEquals(this.fields, other.fields, (l, r) => l.isEqual(r));
     }
-}
-/** Returns true if the Value represents the canonical {@link #MAX_VALUE} . */
-function isMaxValue(value) {
-    return ((((value.mapValue || {}).fields || {})['__type__'] || {}).stringValue ===
-        MAX_VALUE_TYPE);
 }
 
 /**
@@ -3368,11 +3734,12 @@ class ObjectValue {
  * 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;
     }
@@ -3381,18 +3748,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
@@ -3400,17 +3776,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;
     }
     /**
@@ -3419,9 +3808,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;
     }
     /**
@@ -3431,17 +3820,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;
     }
@@ -3450,337 +3839,115 @@ class MutableDocument {
         return this;
     }
     get hasLocalMutations() {
-        return this.documentState === 1 /* HAS_LOCAL_MUTATIONS */;
-    }
-    get hasCommittedMutations() {
-        return this.documentState === 2 /* HAS_COMMITTED_MUTATIONS */;
-    }
-    get hasPendingWrites() {
-        return this.hasLocalMutations || this.hasCommittedMutations;
-    }
-    isValidDocument() {
-        return this.documentType !== 0 /* INVALID */;
-    }
-    isFoundDocument() {
-        return this.documentType === 1 /* FOUND_DOCUMENT */;
-    }
-    isNoDocument() {
-        return this.documentType === 2 /* NO_DOCUMENT */;
-    }
-    isUnknownDocument() {
-        return this.documentType === 3 /* UNKNOWN_DOCUMENT */;
-    }
-    isEqual(other) {
-        return (other instanceof MutableDocument &&
-            this.key.isEqual(other.key) &&
-            this.version.isEqual(other.version) &&
-            this.documentType === other.documentType &&
-            this.documentState === other.documentState &&
-            this.data.isEqual(other.data));
-    }
-    mutableCopy() {
-        return new MutableDocument(this.key, this.documentType, this.version, this.readTime, this.data.clone(), this.documentState);
-    }
-    toString() {
-        return (`Document(${this.key}, ${this.version}, ${JSON.stringify(this.data.value)}, ` +
-            `{documentType: ${this.documentType}}), ` +
-            `{documentState: ${this.documentState}})`);
-    }
-}
-
-/**
- * @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;
-    }
-}
-/**
- * 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 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);
-}
-class Filter {
-}
-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)));
-    }
-    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();
-        }
-    }
-    isInequality() {
-        return ([
-            "<" /* LESS_THAN */,
-            "<=" /* LESS_THAN_OR_EQUAL */,
-            ">" /* GREATER_THAN */,
-            ">=" /* GREATER_THAN_OR_EQUAL */,
-            "!=" /* NOT_EQUAL */,
-            "not-in" /* NOT_IN */
-        ].indexOf(this.op) >= 0);
-    }
-}
-function filterEquals(f1, f2) {
-    return (f1.op === f2.op &&
-        f1.field.isEqual(f2.field) &&
-        valueEquals(f1.value, f2.value));
-}
-/** Filter that matches on key fields (i.e. '__name__'). */
-class KeyFieldFilter extends FieldFilter {
-    constructor(field, op, value) {
-        super(field, op, value);
-        this.key = DocumentKey.fromName(value.referenceValue);
-    }
-    matches(doc) {
-        const comparison = DocumentKey.comparator(doc.key, this.key);
-        return this.matchesComparison(comparison);
-    }
-}
-/** 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);
-    }
-    matches(doc) {
-        return this.keys.some(key => key.isEqual(doc.key));
-    }
-}
-/** 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);
+        return this.documentState === 1 /* DocumentState.HAS_LOCAL_MUTATIONS */;
     }
-    matches(doc) {
-        return !this.keys.some(key => key.isEqual(doc.key));
+    get hasCommittedMutations() {
+        return this.documentState === 2 /* DocumentState.HAS_COMMITTED_MUTATIONS */;
     }
-}
-function extractDocumentKeysFromArrayValue(op, value) {
-    var _a;
-    return (((_a = value.arrayValue) === null || _a === void 0 ? void 0 : _a.values) || []).map(v => {
-        return DocumentKey.fromName(v.referenceValue);
-    });
-}
-/** A Filter that implements the array-contains operator. */
-class ArrayContainsFilter extends FieldFilter {
-    constructor(field, value) {
-        super(field, "array-contains" /* ARRAY_CONTAINS */, value);
+    get hasPendingWrites() {
+        return this.hasLocalMutations || this.hasCommittedMutations;
     }
-    matches(doc) {
-        const other = doc.data.field(this.field);
-        return isArray(other) && arrayValueContains(other.arrayValue, this.value);
+    isValidDocument() {
+        return this.documentType !== 0 /* DocumentType.INVALID */;
     }
-}
-/** A Filter that implements the IN operator. */
-class InFilter extends FieldFilter {
-    constructor(field, value) {
-        super(field, "in" /* IN */, value);
+    isFoundDocument() {
+        return this.documentType === 1 /* DocumentType.FOUND_DOCUMENT */;
     }
-    matches(doc) {
-        const other = doc.data.field(this.field);
-        return other !== null && arrayValueContains(this.value.arrayValue, other);
+    isNoDocument() {
+        return this.documentType === 2 /* DocumentType.NO_DOCUMENT */;
     }
-}
-/** A Filter that implements the not-in operator. */
-class NotInFilter extends FieldFilter {
-    constructor(field, value) {
-        super(field, "not-in" /* NOT_IN */, value);
+    isUnknownDocument() {
+        return this.documentType === 3 /* DocumentType.UNKNOWN_DOCUMENT */;
     }
-    matches(doc) {
-        if (arrayValueContains(this.value.arrayValue, { nullValue: 'NULL_VALUE' })) {
-            return false;
-        }
-        const other = doc.data.field(this.field);
-        return other !== null && !arrayValueContains(this.value.arrayValue, other);
+    isEqual(other) {
+        return (other instanceof MutableDocument &&
+            this.key.isEqual(other.key) &&
+            this.version.isEqual(other.version) &&
+            this.documentType === other.documentType &&
+            this.documentState === other.documentState &&
+            this.data.isEqual(other.data));
     }
-}
-/** 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);
+    mutableCopy() {
+        return new MutableDocument(this.key, this.documentType, this.version, this.readTime, this.createTime, this.data.clone(), this.documentState);
     }
-    matches(doc) {
-        const other = doc.data.field(this.field);
-        if (!isArray(other) || !other.arrayValue.values) {
-            return false;
-        }
-        return other.arrayValue.values.some(val => arrayValueContains(this.value.arrayValue, val));
+    toString() {
+        return (`Document(${this.key}, ${this.version}, ${JSON.stringify(this.data.value)}, ` +
+            `{createTime: ${this.createTime}}), ` +
+            `{documentType: ${this.documentType}}), ` +
+            `{documentState: ${this.documentState}})`);
     }
-}
+}
+
 /**
- * Represents a bound of a query.
+ * @license
+ * Copyright 2019 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;
+// 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;
     }
 }
 /**
- * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
+ * 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.
  */
-class OrderBy {
-    constructor(field, dir = "asc" /* ASCENDING */) {
-        this.field = field;
-        this.dir = dir;
-    }
-}
-function orderByEquals(left, right) {
-    return left.dir === right.dir && left.field.isEqual(right.field);
+function newTarget(path, collectionGroup = null, orderBy = [], filters = [], limit = null, startAt = null, endAt = null) {
+    return new TargetImpl(path, collectionGroup, orderBy, filters, limit, startAt, endAt);
 }
-function boundEquals(left, right) {
-    if (left === null) {
-        return right === null;
+function targetEquals(left, right) {
+    if (left.limit !== right.limit) {
+        return false;
     }
-    else if (right === null) {
+    if (left.orderBy.length !== right.orderBy.length) {
         return false;
     }
-    if (left.inclusive !== right.inclusive ||
-        left.position.length !== right.position.length) {
+    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.position.length; i++) {
-        const leftPosition = left.position[i];
-        const rightPosition = right.position[i];
-        if (!valueEquals(leftPosition, rightPosition)) {
+    for (let i = 0; i < left.filters.length; i++) {
+        if (!filterEquals(left.filters[i], right.filters[i])) {
             return false;
         }
     }
-    return true;
+    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);
 }
 
 /**
@@ -3811,7 +3978,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;
@@ -3838,20 +4005,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;
@@ -3888,7 +4044,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;
@@ -3904,7 +4060,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));
             }
         }
@@ -3917,16 +4073,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.
@@ -3943,6 +4099,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);
 }
@@ -4182,7 +4340,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;
@@ -4209,7 +4367,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;
@@ -4221,7 +4379,7 @@ class DeleteMutation extends Mutation {
         super();
         this.key = key;
         this.precondition = precondition;
-        this.type = 2 /* Delete */;
+        this.type = 2 /* MutationType.Delete */;
         this.fieldTransforms = [];
     }
     getFieldMask() {
@@ -4240,7 +4398,7 @@ class VerifyMutation extends Mutation {
         super();
         this.key = key;
         this.precondition = precondition;
-        this.type = 3 /* Verify */;
+        this.type = 3 /* MutationType.Verify */;
         this.fieldTransforms = [];
     }
     getFieldMask() {
@@ -4266,22 +4424,28 @@ class VerifyMutation extends Mutation {
  */
 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) {
@@ -4433,8 +4597,14 @@ function toMutationDocument(serializer, key, fields) {
 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();
     }
@@ -4446,8 +4616,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);
@@ -4561,7 +4734,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;
     }
@@ -4596,17 +4769,11 @@ function toRunAggregationQueryRequest(serializer, target) {
         parent: queryTarget.parent
     };
 }
-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 { compositeFilter: { op: 'AND', filters: protos } };
+    return toFilter(CompositeFilter.create(filters, "and" /* CompositeOperator.AND */));
 }
 function toOrder(orderBys) {
     if (orderBys.length === 0) {
@@ -4634,6 +4801,9 @@ function toDirection(dir) {
 function toOperatorName(op) {
     return OPERATORS[op];
 }
+function toCompositeOperatorName(op) {
+    return COMPOSITE_OPERATORS[op];
+}
 function toFieldPathReference(path) {
     return { fieldPath: path.canonicalString() };
 }
@@ -4645,8 +4815,31 @@ function toPropertyOrder(orderBy) {
     };
 }
 // 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: {
@@ -4664,7 +4857,7 @@ function toUnaryOrFieldFilter(filter) {
             };
         }
     }
-    else if (filter.op === "!=" /* NOT_EQUAL */) {
+    else if (filter.op === "!=" /* Operator.NOT_EQUAL */) {
         if (isNanValue(filter.value)) {
             return {
                 unaryFilter: {
@@ -6044,12 +6237,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();
@@ -6174,8 +6367,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;
@@ -6206,12 +6399,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');
         }
@@ -6244,7 +6437,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
@@ -6308,7 +6501,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();
@@ -6335,7 +6528,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) {
@@ -6382,7 +6575,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;
 }
@@ -6432,7 +6625,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);
@@ -6874,164 +7067,334 @@ 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 {@link QueryCompositeFilterConstraint} that performs a logical OR
+ * of all the provided {@link QueryFilterConstraint}s.
+ *
+ * @param queryConstraints - Optional. The {@link QueryFilterConstraint}s
+ * for OR operation. These must be created with calls to {@link where},
+ * {@link or}, or {@link and}.
+ * @returns The created {@link QueryCompositeFilterConstraint}.
+ * @internal TODO remove this internal tag with OR Query support in the server
+ */
+function or(...queryConstraints) {
+    // Only support QueryFilterConstraints
+    queryConstraints.forEach(queryConstraint => validateQueryFilterConstraint('or', queryConstraint));
+    return QueryCompositeFilterConstraint._create("or" /* CompositeOperator.OR */, queryConstraints);
+}
+/**
+ * Creates a {@link QueryCompositeFilterConstraint} that performs a logical AND
+ * of all the provided {@link QueryFilterConstraint}s.
+ *
+ * @param queryConstraints - Optional. The {@link QueryFilterConstraint}s
+ * for AND operation. These must be created with calls to {@link where},
+ * {@link or}, or {@link and}.
+ * @returns The created {@link QueryCompositeFilterConstraint}.
+ * @internal TODO remove this internal tag with OR Query support in the server
+ */
+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) {
@@ -7047,10 +7410,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) {
@@ -7063,16 +7426,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) {
@@ -7242,62 +7604,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.
@@ -7315,6 +7699,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(...)))`.');
+    }
 }
 
 /**
@@ -7342,27 +7744,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();
@@ -7515,7 +7917,7 @@ function getDocs(query) {
     const userDataWriter = new LiteUserDataWriter(query.firestore);
     return invokeRunQueryRpc(datastore, query._query).then(result => {
         const docs = result.map(doc => new QueryDocumentSnapshot(query.firestore, userDataWriter, doc.key, doc, query.converter));
-        if (query._query.limitType === "L" /* Last */) {
+        if (query._query.limitType === "L" /* LimitType.Last */) {
             // Limit to last queries reverse the orderBy constraint that was
             // specified by the user. As such, we need to reverse the order of the
             // results to return the documents in the expected order.
@@ -8078,7 +8480,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() {
@@ -8302,7 +8704,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.
@@ -8472,7 +8874,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;
                 }
             }
@@ -8656,14 +9058,21 @@ exports.Firestore = Firestore;
 exports.FirestoreError = FirestoreError;
 exports.GeoPoint = GeoPoint;
 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.Timestamp = Timestamp;
 exports.Transaction = Transaction;
 exports.WriteBatch = WriteBatch;
 exports.addDoc = addDoc;
 exports.aggregateQuerySnapshotEqual = aggregateQuerySnapshotEqual;
+exports.and = and;
 exports.arrayRemove = arrayRemove;
 exports.arrayUnion = arrayUnion;
 exports.collection = collection;
@@ -8683,6 +9092,7 @@ exports.increment = increment;
 exports.initializeFirestore = initializeFirestore;
 exports.limit = limit;
 exports.limitToLast = limitToLast;
+exports.or = or;
 exports.orderBy = orderBy;
 exports.query = query;
 exports.queryEqual = queryEqual;